bool Ini::read()
{
char line[MAXLINE];
uint16_t lc = 1;
while(fgets(line, MAXLINE, file)){
char* p = line;
strip(p);
p = trim(p);
if(strlen(p)){
if(*p == '['){
if(allocData())
return true;
lsc = lc;
if(readSection(p))
return true;
}
else{
if(readValues(p))
return true;
}
}
lc++;
};
if(dc)
allocData();
return false;
}
int main()
{
/*
+ Valuable Detail
- datFile: 파일을 열기위한 FILE 구조체 변수
- datStore: 파일의 내용을 각 항목별로 저장하기 위한 DAT 구조체 변수
- maxDoc: 최대 전표 번호 저장
- dat: 최초의 Raw Data를 받기 위한 배열
- i: 반복문 용 변수
*/
FILE *datFile = fopen("Hoa_20151216.dat","r");
DAT datStore;
DRESULT datResult;
char dat[45];
int i;
//memset(&datResult,0,sizeof(datResult));
int maxDoc = maxDocNum(datFile); // 최대 전표 번호를 구한다.
memset(&datResult,0,sizeof(datResult));
datResult = allocData(maxDoc,datResult); // 최대 전표 수만큼의 값을 갖는 배열들을 생성, 전표 번호와 인덱스를 일치 시켜 값을 저장하기 위한 용도
for(i=0;!feof(datFile);i++)
{
memset(&datStore,0,sizeof(datStore)); // 구조체 변수 datStore를 사용하기 위한 초기화
fgets(dat,sizeof(dat)+1,datFile); // dat 파일의 내용을 한줄씩 받아오기 위한 fgets
dat[strlen(dat)-1] = '\0'; // fgets 함수를 통해 받아온 데이터의 맨 끝의 개행문자를 널문자로 변환
datStore = sortDat(dat,datStore); // 받아온 데이터를 실제 규격에 맞게 정리
datResult = inDresult(datStore, datResult); // 규격에 맞춘 데이터를 이용하여 결과 값 연산
}
showResult(datResult,maxDoc);
fclose(datFile);
return 0;
}
// . if a dump is not going on this uses the primary mem space
// . if a dump is going on and this key has already been dumped
// (we check RdbDump::getFirstKey()/getLastKey()) add it to the
// secondary mem space, otherwise add it to the primary mem space
//void *RdbMem::dupData ( key_t key , char *data , int32_t dataSize ) {
void *RdbMem::dupData ( char *key , char *data , int32_t dataSize ,
collnum_t collnum ) {
char *s = (char *) allocData ( key , dataSize , collnum );
if ( ! s ) return NULL;
gbmemcpy ( s , data , dataSize );
return s;
}
void generateData () {
int k;
int sx;
int sy;
Complex z, w, *c;
if (fracData == NULL) allocData ();
int *fracPoint = fracData;
for (sx = 0; sx < n1; ++sx) {
for (sy = 0; sy < n2; ++sy, ++fracPoint) {
screenToComplex (sx, sy, &w);
z = w;
if (mode == 1) c = &w;
else c = &julia;
for (k = 0; k < MAX_ITERATIONS; ++k) {
z = cmultComplex (&z, &z);
// z = cmultComplex (&z, &z);
z = addComplex (&z, c);
// z = sinComplex (&z);
// z = cmultComplex (c, &z);
// z.real = c->imaginary + z.real;
// z.imaginary = c->real - z.imaginary;
// z = cmultComplex (c, &z);
if (z.real * z.real + z.imaginary * z.imaginary > ESCAPE_RADIUS) break;
}
*fracPoint = k;
}
}
}
block::block(const block&right){
//delete []this->data;
allocData();
this->b_type=right.getType();
this->b_pos=right.getPos();
this->setType(this->b_type);
this->setState(right.getState());
}
block::block():startP(point(6,1)){
init();
setTypeArr();
allocData();
randSet();
setTypeAndState();
randSet();
}
void
loadData(bool forceReload = false)
{
if(m_gotData && !forceReload)
return;
m_gotData = true;
allocData();
CopyPolicy()(m_fileHandler, m_data);
}
/* MemChunk::MemChunk
* MemChunk class constructor
*******************************************************************/
MemChunk::MemChunk(uint32_t size)
{
// Init variables
this->size = size;
this->cur_ptr = 0;
// If a size is specified, allocate that much memory
if (size)
allocData(size);
else
data = NULL;
}
void setFilePath(const std::string& filePath)
{
if(!m_filePath.empty())
m_fileHandler.close();
m_filePath = filePath;
freeData();
m_gotData = false;
if(!filePath.empty()){
m_fileHandler.open(filePath);
if(m_fileHandler.isOpen()){
allocData();
}
}
}
int main() {
float3 *A, *B;
size_t size, i;
size = N;
A=allocData(size);
B=allocData(size);
initData(B,size,2.5);
/* Perform the computation on the device */
#pragma acc parallel loop present(A,B)
for (i=0; i < size; ++i) {
A[i].x = B[i].x + (float) i;
A[i].y = B[i].y + (float) i*2;
A[i].z = B[i].z + (float) i*3;
}
/* Copy back the results */
#pragma acc update self(A[0:size])
printData(A, size);
deleteData(A);
deleteData(B);
exit(0);
}
bool
Reliable::Send( void* data, uint len, bool ordered )
{
K_ASSERT( data != 0 );
K_ASSERT( len > 0 );
processZeroSend(); // To send previously asked ones first.
UdpSendBlock* sb = allocSendBlock();
sb->header.Set( UdpHeader::RLE );
sb->header.Set( UdpHeader::ACK );
if ( ordered )
{
sb->header.Set( UdpHeader::ORD );
}
sb->header.seq = ++m_sendSeq;
sb->header.ack = m_sendCumAck;
sb->header.srcId = m_connection->GetSelfTag();
sb->header.dstId = m_connection->GetRemoteTag();
sb->header.length = sizeof( UdpHeader );
sb->header.bodyLen = len;
sb->data = (byte*)allocData( sizeof( UdpHeader ) + len );
::memcpy( sb->data, (void*)&sb->header, sizeof( UdpHeader ) );
::memcpy( (void*)(sb->data + sb->header.length), data, len );
sb->len = sizeof( UdpHeader ) + len;
if ( m_outstandingSegs < MAX_OUTSTANDING_SEGMENTS )
{
m_connection->SendRaw( sb->data, sb->len );
++sb->rxCount;
++m_outstandingSegs;
m_tickCumulativeAck.Reset();
}
else
{
++m_zeroSendCount;
}
m_sendList.push_back( sb );
return true;
}
/* MemChunk::importFile
* Loads a file (or part of it) into the MemChunk
* Returns false if file couldn't be opened, true otherwise
*******************************************************************/
bool MemChunk::importFile(string filename, uint32_t offset, uint32_t len)
{
// Open the file
wxFile file(filename);
// Return false if file open failed
if (!file.IsOpened())
{
wxLogMessage("MemChunk::importFile: Unable to open file %s", filename);
Global::error = S_FMT("Unable to open file %s", filename);
return false;
}
// Clear current data if it exists
clear();
// If length isn't specified or exceeds the file length,
// only read to the end of the file
if (offset + len > file.Length() || len == 0)
len = file.Length() - offset;
// Setup variables
size = len;
// Read the file
if (size > 0)
{
//data = new uint8_t[size];
if (allocData(size))
{
// Read the file
file.Seek(offset, wxFromStart);
size_t count = file.Read(data, size);
if (count != size)
{
wxLogMessage("MemChunk::importFile: Unable to read full file %s, read %u out of %u",
filename, count, size);
Global::error = S_FMT("Unable to read file %s", filename);
clear();
file.Close();
return false;
}
}
file.Close();
}
return true;
}
void reshape (int width, int height) {
if (height <= 0) height = 1;
if (width <= 0) width = 1;
n1 = width;
n2 = height;
if ((n1 * n2) > fracData_len) allocData ();
generateData ();
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0, width, 0, height);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glViewport (0, 0, (GLsizei)width, (GLsizei)height);
}
struct Data* extractDiffs(int ts, struct Data* oldList, struct Data* newList){
/* Accepts 2 lists of Data structs and iterates through them looking for adapter names that
match. When a matching pair is found the differences between the dl and ul figures are calculated
and if they are non-zero the delta is stored in the 'diffData' list which is evetually returned. This
routine must handle cases where one or both lists are null, where the adapters do not appear in the
same order within the 2 lists, and where adapters are present in one list and not in the other (this
will happen if adapters are enabled or disabled while the application is running). */
BW_INT dl,ul;
// These pointers reference the Data structs that we are currently examining, from each of the 2 lists
struct Data* oldData;
struct Data* newData;
struct Data* diffData = NULL;
struct Data* newDiff = NULL;
oldData = oldList; // Point oldData at the start of the oldList
while(oldData != NULL){
newData = newList; // Point newData at the start of the newList
while(newData != NULL){
if (strcmp(oldData->ad, newData->ad) == 0){
// We found an adapter that appears in both lists, so look at the dl and ul values
if ((newData->dl >= oldData->dl) && (newData->ul >= oldData->ul)){;
dl = newData->dl - oldData->dl;
ul = newData->ul - oldData->ul;
if (dl > 0 || ul > 0){
// At least 1 of the values increased since last time, so we add an item the the diffData list for this adapter
newDiff = allocData();
newDiff->dl = dl;
newDiff->ul = ul;
newDiff->ts = ts;
setAddress(newDiff, oldData->ad);
setHost(newDiff, oldData->hs);
appendData(&diffData, newDiff);
}
} else {
logMsg(LOG_WARN, "Values wrapped around for adapter %s", oldData->ad);
}
break; // We found the match so no point looking at any remaining items in newList
}
newData = newData->next; // We didn't find a match so move to the next item in the newList
}
oldData = oldData->next;
}
return diffData;
}
/* MemChunk::importMem
* Loads a chunk of memory into the MemChunk
* Returns false if size or data pointer is invalid, true otherwise
*******************************************************************/
bool MemChunk::importMem(const uint8_t* start, uint32_t len)
{
// Check that length & data to be loaded are valid
if (!start)
return false;
// Clear current data if it exists
clear();
// Setup variables
size = len;
// Load new data
if (size > 0)
{
if (allocData(size))
memcpy(data, start, size);
else
return false;
}
return true;
}
/* MemChunk::reSize
* Resizes the memory chunk, preserving existing data if specified
* Returns false if new size is invalid, true otherwise
*******************************************************************/
bool MemChunk::reSize(uint32_t new_size, bool preserve_data)
{
// Check for invalid new size
if (new_size == 0)
{
LOG_MESSAGE(1, "MemChunk::reSize: new_size cannot be 0");
return false;
}
// Attempt to allocate memory for new size
uint8_t* ndata = allocData(new_size, false);
if (!ndata)
return false;
// Preserve existing data if specified
if (preserve_data)
{
memcpy(ndata, data, size * sizeof(uint8_t));
delete[] data;
data = ndata;
}
else
{
clear();
data = ndata;
}
// Update variables
size = new_size;
// Check position
if (cur_ptr > size)
cur_ptr = size;
return true;
}
// Function that reads from a MiniSEED binary file from a char buffer and
// returns a LinkedIDList.
LinkedIDList *
readMSEEDBuffer (char *mseed, int buflen, Selections *selections, flag
unpack_data, int reclen, flag verbose, flag details,
int header_byteorder, long (*allocData) (int, char),
void (*diag_print) (char*), void (*log_print) (char*))
{
int retcode = 0;
int retval = 0;
flag swapflag = 0;
// current offset of mseed char pointer
int offset = 0;
// Unpack without reading the data first
flag dataflag = 0;
// the timing_qual of BLK 1001
uint8_t timing_qual = 0xFF;
// the calibration type, availability of BLK 300, 310, 320, 390, 395
int8_t calibration_type = -1;
// Init all the pointers to NULL. Most compilers should do this anyway.
LinkedIDList * idListHead = NULL;
LinkedIDList * idListCurrent = NULL;
LinkedIDList * idListLast = NULL;
MSRecord *msr = NULL;
ContinuousSegment * segmentCurrent = NULL;
hptime_t lastgap = 0;
hptime_t hptimetol = 0;
hptime_t nhptimetol = 0;
long data_offset;
LinkedRecordList *recordHead = NULL;
LinkedRecordList *recordPrevious = NULL;
LinkedRecordList *recordCurrent = NULL;
int datasize;
int record_count = 0;
// A negative verbosity suppressed as much as possible.
if (verbose < 0) {
ms_loginit(&empty_print, NULL, &empty_print, NULL);
}
else {
ms_loginit(log_print, "INFO: ", diag_print, "ERROR: ");
}
if (header_byteorder >= 0) {
// Enforce little endian.
if (header_byteorder == 0) {
MS_UNPACKHEADERBYTEORDER(0);
}
// Enforce big endian.
else {
MS_UNPACKHEADERBYTEORDER(1);
}
}
else {
MS_UNPACKHEADERBYTEORDER(-1);
}
//
// Read all records and save them in a linked list.
//
while (offset < buflen) {
msr = msr_init(NULL);
if ( msr == NULL ) {
ms_log (2, "readMSEEDBuffer(): Error initializing msr\n");
return NULL;
}
if (verbose > 1) {
ms_log(0, "readMSEEDBuffer(): calling msr_parse with "
"mseed+offset=%d+%d, buflen=%d, reclen=%d, dataflag=%d, verbose=%d\n",
mseed, offset, buflen, reclen, dataflag, verbose);
}
// If the record length is given, make sure at least that amount of data is available.
if (reclen != -1) {
if (offset + reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
}
// Otherwise assume the smallest possible record length and assure that enough
// data is present.
else {
if (offset + 256 > buflen) {
ms_log(1, "readMSEEDBuffer(): Last record only has %i byte(s) which "
"is not enough to constitute a full SEED record. Corrupt data? "
"Record will be skipped.\n", buflen - offset);
msr_free(&msr);
break;
}
}
// Pass (buflen - offset) because msr_parse() expects only a single record. This
// way libmseed can take care to not overstep bounds.
retcode = msr_parse ( (mseed+offset), buflen - offset, &msr, reclen, dataflag, verbose);
if (retcode != MS_NOERROR) {
switch ( retcode ) {
case MS_ENDOFFILE:
ms_log(1, "readMSEEDBuffer(): Unexpected end of file when "
"parsing record starting at offset %d. The rest "
"of the file will not be read.\n", offset);
break;
case MS_GENERROR:
ms_log(1, "readMSEEDBuffer(): Generic error when parsing "
"record starting at offset %d. The rest of the "
"file will not be read.\n", offset);
break;
case MS_NOTSEED:
ms_log(1, "readMSEEDBuffer(): Record starting at offset "
"%d is not valid SEED. The rest of the file "
"will not be read.\n", offset);
break;
case MS_WRONGLENGTH:
ms_log(1, "readMSEEDBuffer(): Length of data read was not "
"correct when parsing record starting at "
"offset %d. The rest of the file will not be "
"read.\n", offset);
break;
case MS_OUTOFRANGE:
ms_log(1, "readMSEEDBuffer(): SEED record length out of "
"range for record starting at offset %d. The "
"rest of the file will not be read.\n", offset);
break;
case MS_UNKNOWNFORMAT:
ms_log(1, "readMSEEDBuffer(): Unknown data encoding "
"format for record starting at offset %d. The "
"rest of the file will not be read.\n", offset);
break;
case MS_STBADCOMPFLAG:
ms_log(1, "readMSEEDBuffer(): Invalid STEIM compression "
"flag(s) in record starting at offset %d. The "
"rest of the file will not be read.\n", offset);
break;
default:
ms_log(1, "readMSEEDBuffer(): Unknown error '%d' in "
"record starting at offset %d. The rest of the "
"file will not be read.\n", retcode, offset);
break;
}
msr_free(&msr);
break;
}
if (offset + msr->reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last msr->reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
// Test against selections if supplied
if ( selections ) {
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) {
// Add the record length for the next iteration
offset += msr->reclen;
// Free record.
msr_free(&msr);
continue;
}
}
record_count += 1;
recordCurrent = lrl_init ();
// Append to linked record list if one exists.
if ( recordHead != NULL ) {
recordPrevious->next = recordCurrent;
recordCurrent->previous = recordPrevious;
recordCurrent->next = NULL;
recordPrevious = recordCurrent;
}
// Otherwise create a new one.
else {
recordHead = recordCurrent;
recordCurrent->previous = NULL;
recordPrevious = recordCurrent;
}
recordCurrent->record = msr;
// Determine the byte order swapflag only for the very first record.
// The byte order should not change within the file.
// XXX: Maybe check for every record?
if (swapflag <= 0) {
// Returns 0 if the host is little endian, otherwise 1.
flag bigendianhost = ms_bigendianhost();
// Set the swapbyteflag if it is needed.
if ( msr->Blkt1000 != 0) {
/* If BE host and LE data need swapping */
if ( bigendianhost && msr->byteorder == 0 ) {
swapflag = 1;
}
/* If LE host and BE data (or bad byte order value) need swapping */
if ( !bigendianhost && msr->byteorder > 0 ) {
swapflag = 1;
}
}
}
// Actually unpack the data if the flag is not set.
if (unpack_data != 0) {
retval = msr_unpack_data (msr, swapflag, verbose);
}
if ( retval > 0 ) {
msr->numsamples = retval;
}
// Add the record length for the next iteration
offset += msr->reclen;
}
// Return empty id list if no records could be found.
if (record_count == 0) {
idListHead = lil_init();
return idListHead;
}
// All records that match the selection are now stored in a LinkedRecordList
// that starts at recordHead. The next step is to sort them by matching ids
// and then by time.
recordCurrent = recordHead;
while (recordCurrent != NULL) {
// Check if the ID of the record is already available and if not create a
// new one.
// Start with the last id as it is most likely to be the correct one.
idListCurrent = idListLast;
while (idListCurrent != NULL) {
if (strcmp(idListCurrent->network, recordCurrent->record->network) == 0 &&
strcmp(idListCurrent->station, recordCurrent->record->station) == 0 &&
strcmp(idListCurrent->location, recordCurrent->record->location) == 0 &&
strcmp(idListCurrent->channel, recordCurrent->record->channel) == 0 &&
idListCurrent->dataquality == recordCurrent->record->dataquality) {
break;
}
else {
idListCurrent = idListCurrent->previous;
}
}
// Create a new id list if one is needed.
if (idListCurrent == NULL) {
idListCurrent = lil_init();
idListCurrent->previous = idListLast;
if (idListLast != NULL) {
idListLast->next = idListCurrent;
}
idListLast = idListCurrent;
if (idListHead == NULL) {
idListHead = idListCurrent;
}
// Set the IdList attributes.
strcpy(idListCurrent->network, recordCurrent->record->network);
strcpy(idListCurrent->station, recordCurrent->record->station);
strcpy(idListCurrent->location, recordCurrent->record->location);
strcpy(idListCurrent->channel, recordCurrent->record->channel);
idListCurrent->dataquality = recordCurrent->record->dataquality;
}
// Now check if the current record fits exactly to the end of the last
// segment of the current id. If not create a new segment. Therefore
// if records with the same id are in wrong order a new segment will be
// created. This is on purpose.
segmentCurrent = idListCurrent->lastSegment;
if (segmentCurrent != NULL) {
hptimetol = (hptime_t) (0.5 * segmentCurrent->hpdelta);
nhptimetol = ( hptimetol ) ? -hptimetol : 0;
lastgap = recordCurrent->record->starttime - segmentCurrent->endtime - segmentCurrent->hpdelta;
}
if (details == 1) {
/* extract information on calibration BLKs */
calibration_type = -1;
if (recordCurrent->record->blkts) {
BlktLink *cur_blkt = recordCurrent->record->blkts;
while (cur_blkt) {
switch (cur_blkt->blkt_type) {
case 300:
calibration_type = 1;
break;
case 310:
calibration_type = 2;
break;
case 320:
calibration_type = 3;
break;
case 390:
calibration_type = 4;
break;
case 395:
calibration_type = -2;
break;
default:
break;
}
cur_blkt = cur_blkt->next;
}
}
/* extract information based on timing quality */
timing_qual = 0xFF;
if (recordCurrent->record->Blkt1001 != 0) {
timing_qual = recordCurrent->record->Blkt1001->timing_qual;
}
}
if ( segmentCurrent != NULL &&
segmentCurrent->sampletype == recordCurrent->record->sampletype &&
// Test the default sample rate tolerance: abs(1-sr1/sr2) < 0.0001
MS_ISRATETOLERABLE (segmentCurrent->samprate, recordCurrent->record->samprate) &&
// Check if the times are within the time tolerance
lastgap <= hptimetol && lastgap >= nhptimetol &&
segmentCurrent->timing_qual == timing_qual &&
segmentCurrent->calibration_type == calibration_type) {
recordCurrent->previous = segmentCurrent->lastRecord;
segmentCurrent->lastRecord = segmentCurrent->lastRecord->next = recordCurrent;
segmentCurrent->samplecnt += recordCurrent->record->samplecnt;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
}
// Otherwise create a new segment and add the current record.
else {
segmentCurrent = seg_init();
segmentCurrent->previous = idListCurrent->lastSegment;
if (idListCurrent->lastSegment != NULL) {
idListCurrent->lastSegment->next = segmentCurrent;
}
else {
idListCurrent->firstSegment = segmentCurrent;
}
idListCurrent->lastSegment = segmentCurrent;
segmentCurrent->starttime = recordCurrent->record->starttime;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
segmentCurrent->samprate = recordCurrent->record->samprate;
segmentCurrent->sampletype = recordCurrent->record->sampletype;
segmentCurrent->samplecnt = recordCurrent->record->samplecnt;
// Calculate high-precision sample period
segmentCurrent->hpdelta = (hptime_t) (( recordCurrent->record->samprate ) ?
(HPTMODULUS / recordCurrent->record->samprate) : 0.0);
segmentCurrent->timing_qual = timing_qual;
segmentCurrent->calibration_type = calibration_type;
segmentCurrent->firstRecord = segmentCurrent->lastRecord = recordCurrent;
recordCurrent->previous = NULL;
}
recordPrevious = recordCurrent->next;
recordCurrent->next = NULL;
recordCurrent = recordPrevious;
}
// Now loop over all segments, combine the records and free the msr
// structures.
idListCurrent = idListHead;
while (idListCurrent != NULL)
{
segmentCurrent = idListCurrent->firstSegment;
while (segmentCurrent != NULL) {
if (segmentCurrent->datasamples) {
free(segmentCurrent->datasamples);
}
// Allocate data via a callback function.
if (unpack_data != 0) {
segmentCurrent->datasamples = (void *) allocData(segmentCurrent->samplecnt, segmentCurrent->sampletype);
}
// Loop over all records, write the data to the buffer and free the msr structures.
recordCurrent = segmentCurrent->firstRecord;
data_offset = (long)(segmentCurrent->datasamples);
while (recordCurrent != NULL) {
datasize = recordCurrent->record->samplecnt * ms_samplesize(recordCurrent->record->sampletype);
memcpy((void *)data_offset, recordCurrent->record->datasamples, datasize);
// Free the record.
msr_free(&(recordCurrent->record));
// Increase the data_offset and the record.
data_offset += (long)datasize;
recordCurrent = recordCurrent->next;
}
segmentCurrent = segmentCurrent->next;
}
idListCurrent = idListCurrent->next;
}
return idListHead;
}
Ptr
getAllocatedMemory()
{
allocData();
return m_data.getData();
}
// Function that reads from a MiniSEED binary file from a char buffer and
// returns a LinkedIDList.
LinkedIDList *
readMSEEDBuffer (char *mseed, int buflen, Selections *selections, flag
unpack_data, int reclen, flag verbose, flag details,
int header_byteorder, long long (*allocData) (int, char),
void (*diag_print) (char*), void (*log_print) (char*))
{
int retcode = 0;
int retval = 0;
flag swapflag = 0;
flag bigendianhost = ms_bigendianhost();
// current offset of mseed char pointer
int offset = 0;
// Unpack without reading the data first
flag dataflag = 0;
// the timing_qual of BLK 1001
uint8_t timing_qual = 0xFF;
// the calibration type, availability of BLK 300, 310, 320, 390, 395
int8_t calibration_type = -1;
// Init all the pointers to NULL. Most compilers should do this anyway.
LinkedIDList * idListHead = NULL;
LinkedIDList * idListCurrent = NULL;
LinkedIDList * idListLast = NULL;
MSRecord *msr = NULL;
ContinuousSegment * segmentCurrent = NULL;
hptime_t lastgap = 0;
hptime_t hptimetol = 0;
hptime_t nhptimetol = 0;
long long data_offset;
LinkedRecordList *recordHead = NULL;
LinkedRecordList *recordPrevious = NULL;
LinkedRecordList *recordCurrent = NULL;
int datasize;
int record_count = 0;
// A negative verbosity suppresses as much as possible.
if (verbose < 0) {
ms_loginit(&empty_print, NULL, &empty_print, NULL);
}
else {
ms_loginit(log_print, "INFO: ", diag_print, "ERROR: ");
}
if (header_byteorder >= 0) {
// Enforce little endian.
if (header_byteorder == 0) {
MS_UNPACKHEADERBYTEORDER(0);
}
// Enforce big endian.
else {
MS_UNPACKHEADERBYTEORDER(1);
}
}
else {
MS_UNPACKHEADERBYTEORDER(-1);
}
// Read all records and save them in a linked list.
while (offset < buflen) {
msr = msr_init(NULL);
if ( msr == NULL ) {
ms_log (2, "readMSEEDBuffer(): Error initializing msr\n");
return NULL;
}
if (verbose > 1) {
ms_log(0, "readMSEEDBuffer(): calling msr_parse with "
"mseed+offset=%d+%d, buflen=%d, reclen=%d, dataflag=%d, verbose=%d\n",
mseed, offset, buflen, reclen, dataflag, verbose);
}
// If the record length is given, make sure at least that amount of data is available.
if (reclen != -1) {
if (offset + reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
}
// Otherwise assume the smallest possible record length and assure that enough
// data is present.
else {
if (offset + MINRECLEN > buflen) {
ms_log(1, "readMSEEDBuffer(): Last record only has %i byte(s) which "
"is not enough to constitute a full SEED record. Corrupt data? "
"Record will be skipped.\n", buflen - offset);
msr_free(&msr);
break;
}
}
// Skip empty or noise records.
if (OBSPY_ISVALIDBLANK(mseed + offset)) {
offset += MINRECLEN;
continue;
}
// Pass (buflen - offset) because msr_parse() expects only a single record. This
// way libmseed can take care to not overstep bounds.
// Return values:
// 0 : Success, populates the supplied MSRecord.
// >0 : Data record detected but not enough data is present, the
// return value is a hint of how many more bytes are needed.
// <0 : libmseed error code (listed in libmseed.h) is returned.
retcode = msr_parse ((mseed+offset), buflen - offset, &msr, reclen, dataflag, verbose);
// Handle error.
if (retcode < 0) {
log_error(retcode, offset);
msr_free(&msr);
break;
}
// msr_parse() returns > 0 if a data record has been detected but the buffer either has not enough
// data (this cannot happen with ObsPy's logic) or the last record has no Blockette 1000 and it cannot
// determine the record length because there is no next record (this can happen in ObsPy) - handle that
// case by just calling msr_parse() with an explicit record length set.
else if ( retcode > 0 && retcode < (buflen - offset)) {
// Check if the remaining bytes can exactly make up a record length.
int r_bytes = buflen - offset;
float exp = log10((float)r_bytes) / log10(2.0);
if ((fmodf(exp, 1.0) < 0.0000001) && ((int)roundf_(exp) >= 7) && ((int)roundf_(exp) <= 256)) {
retcode = msr_parse((mseed + offset), buflen - offset, &msr, r_bytes, dataflag, verbose);
if ( retcode != 0 ) {
log_error(retcode, offset);
msr_free(&msr);
break;
}
}
else {
msr_free(&msr);
break;
}
}
if (offset + msr->reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last msr->reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
// Test against selections if supplied
if ( selections ) {
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) {
// Add the record length for the next iteration
offset += msr->reclen;
// Free record.
msr_free(&msr);
continue;
}
}
record_count += 1;
recordCurrent = lrl_init ();
// Append to linked record list if one exists.
if ( recordHead != NULL ) {
recordPrevious->next = recordCurrent;
recordCurrent->previous = recordPrevious;
recordCurrent->next = NULL;
recordPrevious = recordCurrent;
}
// Otherwise create a new one.
else {
recordHead = recordCurrent;
recordCurrent->previous = NULL;
recordPrevious = recordCurrent;
}
recordCurrent->record = msr;
// Figure out if the byte-order of the data has to be swapped.
swapflag = 0;
// If blockette 1000 is present, use it.
if ( msr->Blkt1000 != 0) {
/* If BE host and LE data need swapping */
if ( bigendianhost && msr->byteorder == 0 ) {
swapflag = 1;
}
/* If LE host and BE data (or bad byte order value) need swapping */
if ( !bigendianhost && msr->byteorder > 0 ) {
swapflag = 1;
}
}
// Otherwise assume the data has the same byte order as the header.
// This needs to be done on the raw header bytes as libmseed only returns
// header fields in the native byte order.
else {
unsigned char* _t = (unsigned char*)mseed + offset + 20;
unsigned int year = _t[0] | _t[1] << 8;
unsigned int day = _t[2] | _t[3] << 8;
// Swap data if header needs to be swapped.
if (!MS_ISVALIDYEARDAY(year, day)) {
swapflag = 1;
}
}
// Actually unpack the data if the flag is not set and if the data
// offset is valid.
if ((unpack_data != 0) && (msr->fsdh->data_offset >= 48) &&
(msr->fsdh->data_offset < msr->reclen) &&
(msr->samplecnt > 0)) {
retval = msr_unpack_data (msr, swapflag, verbose);
}
if ( retval > 0 ) {
msr->numsamples = retval;
}
if ( msr->fsdh->start_time.fract > 9999 ) {
ms_log(1, "readMSEEDBuffer(): Record with offset=%d has a "
"fractional second (.0001 seconds) of %d. This is not "
"strictly valid but will be interpreted as one or more "
"additional seconds.",
offset, msr->fsdh->start_time.fract);
}
// Add the record length for the next iteration
offset += msr->reclen;
}
// Return empty id list if no records could be found.
if (record_count == 0) {
idListHead = lil_init();
return idListHead;
}
// All records that match the selection are now stored in a LinkedRecordList
// that starts at recordHead. The next step is to sort them by matching ids
// and then by time.
recordCurrent = recordHead;
while (recordCurrent != NULL) {
// Check if the ID of the record is already available and if not create a
// new one.
// Start with the last id as it is most likely to be the correct one.
idListCurrent = idListLast;
while (idListCurrent != NULL) {
if (strcmp(idListCurrent->network, recordCurrent->record->network) == 0 &&
strcmp(idListCurrent->station, recordCurrent->record->station) == 0 &&
strcmp(idListCurrent->location, recordCurrent->record->location) == 0 &&
strcmp(idListCurrent->channel, recordCurrent->record->channel) == 0 &&
idListCurrent->dataquality == recordCurrent->record->dataquality) {
break;
}
else {
idListCurrent = idListCurrent->previous;
}
}
// Create a new id list if one is needed.
if (idListCurrent == NULL) {
idListCurrent = lil_init();
idListCurrent->previous = idListLast;
if (idListLast != NULL) {
idListLast->next = idListCurrent;
}
idListLast = idListCurrent;
if (idListHead == NULL) {
idListHead = idListCurrent;
}
// Set the IdList attributes.
strcpy(idListCurrent->network, recordCurrent->record->network);
strcpy(idListCurrent->station, recordCurrent->record->station);
strcpy(idListCurrent->location, recordCurrent->record->location);
strcpy(idListCurrent->channel, recordCurrent->record->channel);
idListCurrent->dataquality = recordCurrent->record->dataquality;
}
// Now check if the current record fits exactly to the end of the last
// segment of the current id. If not create a new segment. Therefore
// if records with the same id are in wrong order a new segment will be
// created. This is on purpose.
segmentCurrent = idListCurrent->lastSegment;
if (segmentCurrent != NULL) {
hptimetol = (hptime_t) (0.5 * segmentCurrent->hpdelta);
nhptimetol = ( hptimetol ) ? -hptimetol : 0;
lastgap = recordCurrent->record->starttime - segmentCurrent->endtime - segmentCurrent->hpdelta;
}
if (details == 1) {
/* extract information on calibration BLKs */
calibration_type = -1;
if (recordCurrent->record->blkts) {
BlktLink *cur_blkt = recordCurrent->record->blkts;
while (cur_blkt) {
switch (cur_blkt->blkt_type) {
case 300:
calibration_type = 1;
break;
case 310:
calibration_type = 2;
break;
case 320:
calibration_type = 3;
break;
case 390:
calibration_type = 4;
break;
case 395:
calibration_type = -2;
break;
default:
break;
}
cur_blkt = cur_blkt->next;
}
}
/* extract information based on timing quality */
timing_qual = 0xFF;
if (recordCurrent->record->Blkt1001 != 0) {
timing_qual = recordCurrent->record->Blkt1001->timing_qual;
}
}
if ( segmentCurrent != NULL &&
// This is important for zero data record coupled with not unpacking
// the data. It needs to be split in two places: Before the zero data
// record and after it.
recordCurrent->record->samplecnt > 0 && segmentCurrent->samplecnt > 0 &&
segmentCurrent->sampletype == recordCurrent->record->sampletype &&
// Test the default sample rate tolerance: abs(1-sr1/sr2) < 0.0001
MS_ISRATETOLERABLE (segmentCurrent->samprate, recordCurrent->record->samprate) &&
// Check if the times are within the time tolerance
lastgap <= hptimetol && lastgap >= nhptimetol &&
segmentCurrent->timing_qual == timing_qual &&
segmentCurrent->calibration_type == calibration_type) {
recordCurrent->previous = segmentCurrent->lastRecord;
segmentCurrent->lastRecord = segmentCurrent->lastRecord->next = recordCurrent;
segmentCurrent->samplecnt += recordCurrent->record->samplecnt;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
}
// Otherwise create a new segment and add the current record.
else {
segmentCurrent = seg_init();
segmentCurrent->previous = idListCurrent->lastSegment;
if (idListCurrent->lastSegment != NULL) {
idListCurrent->lastSegment->next = segmentCurrent;
}
else {
idListCurrent->firstSegment = segmentCurrent;
}
idListCurrent->lastSegment = segmentCurrent;
segmentCurrent->starttime = recordCurrent->record->starttime;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
segmentCurrent->samprate = recordCurrent->record->samprate;
segmentCurrent->sampletype = recordCurrent->record->sampletype;
segmentCurrent->samplecnt = recordCurrent->record->samplecnt;
// Calculate high-precision sample period
segmentCurrent->hpdelta = (hptime_t) (( recordCurrent->record->samprate ) ?
(HPTMODULUS / recordCurrent->record->samprate) : 0.0);
segmentCurrent->timing_qual = timing_qual;
segmentCurrent->calibration_type = calibration_type;
segmentCurrent->firstRecord = segmentCurrent->lastRecord = recordCurrent;
recordCurrent->previous = NULL;
}
recordPrevious = recordCurrent->next;
recordCurrent->next = NULL;
recordCurrent = recordPrevious;
}
// Now loop over all segments, combine the records and free the msr
// structures.
idListCurrent = idListHead;
while (idListCurrent != NULL)
{
segmentCurrent = idListCurrent->firstSegment;
while (segmentCurrent != NULL) {
if (segmentCurrent->datasamples) {
free(segmentCurrent->datasamples);
}
// Allocate data via a callback function.
if (unpack_data != 0) {
segmentCurrent->datasamples = (void *) allocData(segmentCurrent->samplecnt, segmentCurrent->sampletype);
}
// Loop over all records, write the data to the buffer and free the msr structures.
recordCurrent = segmentCurrent->firstRecord;
data_offset = (long long)(segmentCurrent->datasamples);
while (recordCurrent != NULL) {
datasize = recordCurrent->record->samplecnt * ms_samplesize(recordCurrent->record->sampletype);
memcpy((void *)data_offset, recordCurrent->record->datasamples, datasize);
// Free the record.
msr_free(&(recordCurrent->record));
// Increase the data_offset and the record.
data_offset += (long long)datasize;
recordCurrent = recordCurrent->next;
}
segmentCurrent = segmentCurrent->next;
}
idListCurrent = idListCurrent->next;
}
return idListHead;
}
void *data() {
if(!isAllocated())
allocData();
return this->addr;
}
int main(void)
{
ListNode* testList = NULL;
ListNode* node = listPushBack(&testList);
node->data = allocData(1);
printf("test 1\nsize = %u, last id = %i\n", listSize(&testList), getId(listBack(&testList)->data));
//--------
for(int i = 0; i < 100; ++i) {
node = listPushBack(&testList); //->data = allocData(i);
node->data = allocData(i);
}
printf("test 2\nsize = %u, last id = %i\n", listSize(&testList), getId(listBack(&testList)->data));
//--------
for(int i = 0; i < 100; ++i) {
node = listPushFront(&testList);
node->data = allocData(i);
}
printf("test 3\nsize = %u, first id = %i\n", listSize(&testList), getId(listFront(&testList)->data));
//--------
for(int i = 0; i < 100; ++i) {
node = listInsert(listNext(&testList, 50));
node->data = allocData(i);
}
printf("test 4\nsize = %u, id(100) = %i\n", listSize(&testList), getId(listNext(&testList, 100)->data));
//--------
listFree(&testList);
if(listEmpty(&testList))
printf("test4: list empty\n");
//--------
for(int i = 0; i < 100; ++i) {
node = listPushFront(&testList);
node->data = allocData(i);
}
listErase(&testList, listFront(&testList));
printf("test 5\nsize = %u, id(0) = %i\n", listSize(&testList), getId(listFront(&testList)->data));
listErase(&testList, listFront(&testList));
//--------------
listEraseRange(&testList, listNext(testList, 10), listNext(testList, 20));
node = testList;
for(int i = 0; i < 30; ++i) {
printf("id(%d) = %d\n", i, ((ListData*)(node->data))->id);
node = node->next;
}
printf("test 6\nsize = %u, id(10) = %i\n", listSize(&testList), getId(listFront(&testList)->data));
//--------------
listPopBack(&testList);
printf("test 7\nsize = %u, id(back) = %i\n", listSize(&testList), getId(listBack(&testList)->data));
//--------------
listPopFront(&testList);
printf("test 8\nsize = %u, id(front) = %i\n", listSize(&testList), getId(listFront(&testList)->data));
//--------------
listResize(&testList, 10);
printf("test 9\nsize = %u, id(back) = %i\n", listSize(&testList), getId(listBack(&testList)->data));
//--------------
listResize(&testList, 20);
node = testList;
for(int i = 0; i < 20; ++i) {
node->data = allocData(i);
node = node->next;
}
printf("test 10\nsize = %u, id(back) = %i\n", listSize(&testList), getId(listBack(&testList)->data));
return 0;
}
void
Reliable::OnRecv( const UdpHeader& header, void* data, uint len )
{
K_ASSERT( data != 0 );
K_ASSERT( len > 0 );
K_ASSERT( header.length < len );
K_ASSERT( header.IsSet( UdpHeader::RLE) );
if ( header.seq <= m_sendCumAck )
{
LOG( FT_DEBUG,
_T("Reliable::OnRecv> self[%d] remote[%d] dup %d checked by m_sendCumAck %d"),
m_connection->GetSelfTag(),
m_connection->GetRemoteTag(),
header.seq,
m_sendCumAck );
return;
}
byte* p = (byte*)data;
byte* head = (byte*)(p + header.length);
// save payload only
data = (void*)head;
len = len - header.length;
LOG( FT_DEBUG, _T("Reliable::OnRecv> self[%d] remote[%d] seq %d"),
m_connection->GetSelfTag(),
m_connection->GetRemoteTag(),
header.seq );
// if in sequence
if ( header.seq == m_sendCumAck + 1 )
{
LOG( FT_DEBUG, _T("Reliable::OnRecv> In order %d"), header.seq );
m_communicator->OnRecv( m_connection->GetRemoteTag(), data, len );
++m_sendCumAck;
clearIfExists( m_sendCumAck );
K_ASSERT( header.seq == m_sendCumAck );
m_cumAckInterval = CUMULATIVE_ACK_INTERVAL;
}
else
{
LOG( FT_DEBUG, _T("Reliable::OnRecv> Out of order %d"), header.seq );
if ( isDuplicateRecv( header.seq ) )
{
LOG( FT_DEBUG, _T("Reliable::OnRecv> Dup %d check by search"), header.seq );
return;
}
UdpRecvBlock* rv = allocRecvBlock();
rv->ordered = false;
rv->seq = header.seq;
rv->ackCount = 0;
if ( header.IsSet( UdpHeader::ORD ) )
{
rv->ordered = true;
rv->data = allocData( len );
rv->len = len;
::memcpy( rv->data, data, len );
}
else
{
m_communicator->OnRecv( m_connection->GetRemoteTag(), data, len );
}
K_ASSERT( rv->seq > m_sendCumAck );
insertRecvBlock( rv );
runRecvBlockList();
// only 1 eak is used.
// send immediately when not in order
sendEak( header.seq );
m_tickCumulativeAck.Reset();
}
}
// Function that reads from a MiniSEED binary file from a char buffer and
// returns a LinkedIDList.
LinkedIDList *
readMSEEDBuffer (char *mseed, int buflen, Selections *selections, flag
unpack_data, int reclen, flag verbose, flag details,
long (*allocData) (int, char))
{
int retcode = 0;
int retval = 0;
flag swapflag = 0;
// current offset of mseed char pointer
int offset = 0;
// Unpack without reading the data first
flag dataflag = 0;
// the timing_qual of BLK 1001
uint8_t timing_qual = 0xFF;
// the calibration type, availability of BLK 300, 310, 320, 390, 395
int8_t calibration_type = -1;
// Init all the pointers to NULL. Most compilers should do this anyway.
LinkedIDList * idListHead = NULL;
LinkedIDList * idListCurrent = NULL;
LinkedIDList * idListLast = NULL;
MSRecord *msr = NULL;
ContinuousSegment * segmentCurrent = NULL;
hptime_t lastgap;
hptime_t hptimetol;
hptime_t nhptimetol;
long data_offset;
LinkedRecordList *recordHead = NULL;
LinkedRecordList *recordPrevious = NULL;
LinkedRecordList *recordCurrent = NULL;
int datasize;
//
// Read all records and save them in a linked list.
//
int record_count = 0;
while (offset < buflen) {
msr = msr_init(NULL);
retcode = msr_parse ( (mseed+offset), buflen, &msr, reclen, dataflag, verbose);
if ( ! (retcode == MS_NOERROR)) {
msr_free(&msr);
break;
}
// Test against selections if supplied
if ( selections ) {
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) {
// Add the record length for the next iteration
offset += msr->reclen;
// Free record.
msr_free(&msr);
continue;
}
}
record_count += 1;
recordCurrent = lrl_init ();
// Append to linked record list if one exists.
if ( recordHead != NULL ) {
recordPrevious->next = recordCurrent;
recordCurrent->previous = recordPrevious;
recordCurrent->next = NULL;
recordPrevious = recordCurrent;
}
// Otherwise create a new one.
else {
recordHead = recordCurrent;
recordCurrent->previous = NULL;
recordPrevious = recordCurrent;
}
recordCurrent->record = msr;
// Determine the byteorder swapflag only for the very first record. The byteorder
// should not change within the file.
// XXX: Maybe check for every record?
if (swapflag <= 0) {
// Returns 0 if the host is little endian, otherwise 1.
flag bigendianhost = ms_bigendianhost();
// Set the swapbyteflag if it is needed.
if ( msr->Blkt1000 != 0) {
/* If BE host and LE data need swapping */
if ( bigendianhost && msr->byteorder == 0 ) {
swapflag = 1;
}
/* If LE host and BE data (or bad byte order value) need swapping */
if ( !bigendianhost && msr->byteorder > 0 ) {
swapflag = 1;
}
}
}
// Actually unpack the data if the flag is not set.
if (unpack_data != 0) {
retval = msr_unpack_data (msr, swapflag, verbose);
}
if ( retval > 0 ) {
msr->numsamples = retval;
}
// Add the record length for the next iteration
offset += msr->reclen;
}
// Return empty id list if no records could be found.
if (record_count == 0) {
idListHead = lil_init();
return idListHead;
}
// All records that match the selection are now stored in a LinkedRecordList
// that starts at recordHead. The next step is to sort them by matching ids
// and then by time.
recordCurrent = recordHead;
while (recordCurrent != NULL) {
// Check if the ID of the record is already available and if not create a
// new one.
// Start with the last id as it is most likely to be the correct one.
idListCurrent = idListLast;
while (idListCurrent != NULL) {
if (strcmp(idListCurrent->network, recordCurrent->record->network) == 0 &&
strcmp(idListCurrent->station, recordCurrent->record->station) == 0 &&
strcmp(idListCurrent->location, recordCurrent->record->location) == 0 &&
strcmp(idListCurrent->channel, recordCurrent->record->channel) == 0 &&
idListCurrent->dataquality == recordCurrent->record->dataquality) {
break;
}
else {
idListCurrent = idListCurrent->previous;
}
}
// Create a new id list if one is needed.
if (idListCurrent == NULL) {
idListCurrent = lil_init();
idListCurrent->previous = idListLast;
if (idListLast != NULL) {
idListLast->next = idListCurrent;
}
idListLast = idListCurrent;
if (idListHead == NULL) {
idListHead = idListCurrent;
}
// Set the IdList attributes.
strcpy(idListCurrent->network, recordCurrent->record->network);
strcpy(idListCurrent->station, recordCurrent->record->station);
strcpy(idListCurrent->location, recordCurrent->record->location);
strcpy(idListCurrent->channel, recordCurrent->record->channel);
idListCurrent->dataquality = recordCurrent->record->dataquality;
}
// Now check if the current record fits exactly to the end of the last
// segment of the current id. If not create a new segment. Therefore
// if records with the same id are in wrong order a new segment will be
// created. This is on purpose.
segmentCurrent = idListCurrent->lastSegment;
if (segmentCurrent != NULL) {
hptimetol = (hptime_t) (0.5 * segmentCurrent->hpdelta);
nhptimetol = ( hptimetol ) ? -hptimetol : 0;
lastgap = recordCurrent->record->starttime - segmentCurrent->endtime - segmentCurrent->hpdelta;
}
if (details == 1) {
/* extract information on calibration BLKs */
calibration_type = -1;
if (recordCurrent->record->blkts) {
BlktLink *cur_blkt = recordCurrent->record->blkts;
while (cur_blkt) {
switch (cur_blkt->blkt_type) {
case 300:
calibration_type = 1;
break;
case 310:
calibration_type = 2;
break;
case 320:
calibration_type = 3;
break;
case 390:
calibration_type = 4;
break;
case 395:
calibration_type = -2;
break;
default:
break;
}
cur_blkt = cur_blkt->next;
}
}
/* extract information based on timing quality */
timing_qual = 0xFF;
if (recordCurrent->record->Blkt1001 != 0) {
timing_qual = recordCurrent->record->Blkt1001->timing_qual;
}
}
if ( segmentCurrent != NULL &&
segmentCurrent->sampletype == recordCurrent->record->sampletype &&
// Test the default sample rate tolerance: abs(1-sr1/sr2) < 0.0001
MS_ISRATETOLERABLE (segmentCurrent->samprate, recordCurrent->record->samprate) &&
// Check if the times are within the time tolerance
lastgap <= hptimetol && lastgap >= nhptimetol &&
segmentCurrent->timing_qual == timing_qual &&
segmentCurrent->calibration_type == calibration_type) {
recordCurrent->previous = segmentCurrent->lastRecord;
segmentCurrent->lastRecord = segmentCurrent->lastRecord->next = recordCurrent;
segmentCurrent->samplecnt += recordCurrent->record->samplecnt;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
}
// Otherwise create a new segment and add the current record.
else {
segmentCurrent = seg_init();
segmentCurrent->previous = idListCurrent->lastSegment;
if (idListCurrent->lastSegment != NULL) {
idListCurrent->lastSegment->next = segmentCurrent;
}
else {
idListCurrent->firstSegment = segmentCurrent;
}
idListCurrent->lastSegment = segmentCurrent;
segmentCurrent->starttime = recordCurrent->record->starttime;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
segmentCurrent->samprate = recordCurrent->record->samprate;
segmentCurrent->sampletype = recordCurrent->record->sampletype;
segmentCurrent->samplecnt = recordCurrent->record->samplecnt;
// Calculate high-precision sample period
segmentCurrent->hpdelta = (hptime_t) (( recordCurrent->record->samprate ) ?
(HPTMODULUS / recordCurrent->record->samprate) : 0.0);
segmentCurrent->timing_qual = timing_qual;
segmentCurrent->calibration_type = calibration_type;
segmentCurrent->firstRecord = segmentCurrent->lastRecord = recordCurrent;
recordCurrent->previous = NULL;
}
recordPrevious = recordCurrent->next;
recordCurrent->next = NULL;
recordCurrent = recordPrevious;
}
// Now loop over all segments, combine the records and free the msr
// structures.
idListCurrent = idListHead;
while (idListCurrent != NULL)
{
segmentCurrent = idListCurrent->firstSegment;
while (segmentCurrent != NULL) {
if (segmentCurrent->datasamples) {
free(segmentCurrent->datasamples);
}
// Allocate data via a callback function.
if (unpack_data != 0) {
segmentCurrent->datasamples = (void *) allocData(segmentCurrent->samplecnt, segmentCurrent->sampletype);
}
// Loop over all records, write the data to the buffer and free the msr structures.
recordCurrent = segmentCurrent->firstRecord;
data_offset = (long)(segmentCurrent->datasamples);
while (recordCurrent != NULL) {
datasize = recordCurrent->record->samplecnt * ms_samplesize(recordCurrent->record->sampletype);
memcpy((void *)data_offset, recordCurrent->record->datasamples, datasize);
// Free the record.
msr_free(&(recordCurrent->record));
// Increase the data_offset and the record.
data_offset += (long)datasize;
recordCurrent = recordCurrent->next;
}
segmentCurrent = segmentCurrent->next;
}
idListCurrent = idListCurrent->next;
}
return idListHead;
}
// . when a dump completes we free the primary mem space and make
// the secondary mem space the new primary mem space
void RdbMem::freeDumpedMem( RdbTree *tree ) {
// bail if we have no mem
if ( m_memSize == 0 ) return;
log("rdbmem: start freeing dumped mem");
//char *memEnd = m_mem + m_memSize;
// this should still be true so allocData() returns m_ptr2 ptrs
if ( ! m_rdb->m_inDumpLoop ) { g_process.shutdownAbort(true); }
// count how many data nodes we had to move to avoid corruption
int32_t count = 0;
int32_t scanned = 0;
for ( int32_t i = 0 ; i < tree->m_minUnusedNode ; i++ ) {
// give up control to handle search query stuff of niceness 0
QUICKPOLL ( MAX_NICENESS );
// skip node if parents is -2 (unoccupied)
if ( tree->m_parents[i] == -2 ) continue;
scanned++;
// get the ptr
char *data = tree->m_data[i];
if ( ! data ) continue;
// how could it's data not be stored in here?
// if ( data < m_mem ) {
// log("rdbmem: bad data1");
// continue;
// }
// if ( data >= memEnd ) {
// log("rdbmem: bad data2");
// continue;
// }
// is it in primary mem? m_ptr1 mem was just dump
// if growing upward
bool needsMove = false;
// if the primary mem (that was dumped) is
// growing upwards
if ( m_ptr1 < m_ptr2 ) {
// and the node data is in it...
if ( data < m_ptr1 )
needsMove = true;
}
// growing downward otherwise
else if ( data >= m_ptr1 ) {
needsMove = true;
}
if ( ! needsMove ) continue;
// move it. m_inDumpLoop should still
// be true so we will get added to
// m_ptr2
int32_t size;
if ( tree->m_sizes ) size = tree->m_sizes[i];
else size = tree->m_fixedDataSize;
if ( size < 0 ) { g_process.shutdownAbort(true); }
if ( size == 0 ) continue;
// m_inDumpLoop is still true at this point so
// so allocData should return m_ptr2 guys
char *newData = (char *)allocData(NULL,size,0);
if ( ! newData ) {
log("rdbmem: failed to alloc %i "
"bytes node %i",(int)size,(int)i);
continue;
}
// debug test
bool stillNeedsMove = false;
if ( m_ptr1 < m_ptr2 ) {
// and the node data is in it...
if ( newData < m_ptr1 )
stillNeedsMove = true;
}
// growing downward otherwise
else if ( newData >= m_ptr1 ) {
stillNeedsMove = true;
}
if ( stillNeedsMove ) {// this should never happen!!
log("rdbmem: olddata=0x%" PTRFMT" newdata=0x%" PTRFMT,
(PTRTYPE)data, (PTRTYPE)newData);
log("rdbmem: still needs move!");
}
count++;
gbmemcpy(newData,data,size);
tree->m_data[i] = newData;
}
if ( count > 0 )
log("rdbmem: moved %i tree nodes for %s",(int)count,
m_rdb->m_dbname);
log("rdbmem: stop freeing dumped mem. scanned %i nodes.",(int)scanned);
// save primary ptr
char *tmp = m_ptr1;
// debug
//logf(LOG_DEBUG,
// "db: freeing dumped mem ptr1=%" PRIx32" ptr2=%" PRIx32".",m_ptr1,m_ptr2);
// primary pointer, m_ptr1, becomes m_ptr2
m_ptr1 = m_ptr2;
// secondary ptr becomes primary
m_ptr2 = tmp;
// reset secondary (old primary mem was dumped out to disk)
if ( m_ptr2 > m_ptr1 ) m_ptr2 = m_mem + m_memSize;
else m_ptr2 = m_mem;
// no longer 90% full
m_is90PercentFull = false;
}
/* MemChunk::importFileStream
* Loads a file (or part of it) from a currently open file stream
* into the MemChunk
* Returns false if file couldn't be opened, true otherwise
*******************************************************************/
bool MemChunk::importFileStream(wxFile& file, uint32_t len)
{
// Check file
if (!file.IsOpened())
return false;
// Clear current data if it exists
clear();
// Get current file position
uint32_t offset = file.Tell();
// If length isn't specified or exceeds the file length,
// only read to the end of the file
if (offset + len > file.Length() || len == 0)
len = file.Length() - offset;
// Setup variables
size = len;
// Read the file
if (size > 0)
{
//data = new uint8_t[size];
if (allocData(size))
file.Read(data, size);
else
return false;
}
return true;
}
