static void *coalesce(void *bp) { #ifdef __DEBUG__ fprintf(stderr, "Coalescing...\n"); #endif size_t p = isAllocated(getBlockHeader(getPrevBlock(bp))); //allocated "physically" previous block? size_t n = isAllocated(getBlockHeader(getNextBlock(bp))); //allocated "physicall" next block? size_t size = getSize(getBlockHeader(bp)); //get block size if(p && n) { //no coalescing return bp; } else if(!p && n) //previous block is empty! { #ifdef __DEBUG__ fprintf(stderr, "Merging %u(size : %u) and %u(size : %u)...\n", getPrevBlock(bp), getSize(getBlockHeader(getPrevBlock(bp))), bp, getSize(getBlockHeader(bp))); #endif erase(size, bp); //delete current block erase(getSize(getBlockHeader(getPrevBlock(bp))), getPrevBlock(bp)); //delete previous block size += getSize(getBlockHeader(getPrevBlock(bp))); set(getBlockFooter(bp), setMask(size, 0)); set(getBlockHeader(getPrevBlock(bp)), setMask(size, 0)); push_back(size, getPrevBlock(bp)); //add summed block return getPrevBlock(bp); } else if(p && !n) //next block is empty! { #ifdef __DEBUG__ fprintf(stderr, "Merging %u(size : %u) and %u(size : %u)...\n", bp, getSize(getBlockHeader(bp)), getNextBlock(bp), getSize(getBlockHeader(getNextBlock(bp)))); #endif erase(size, bp); //delete current erase(getSize(getBlockHeader(getNextBlock(bp))), getNextBlock(bp)); //delete next size += getSize(getBlockHeader(getNextBlock(bp))); set(getBlockHeader(bp), setMask(size, 0)); set(getBlockFooter(bp), setMask(size, 0)); push_back(size, bp); //add summed block return bp; } else //both block are empty! { #ifdef __DEBUG__ fprintf(stderr, "Merging %u(size : %u), %u(size : %u) and %u(size : %u)...\n", getPrevBlock(bp), getSize(getBlockHeader(getPrevBlock(bp))), bp, getSize(getBlockHeader(bp)), getNextBlock(bp), getSize(getBlockHeader(getNextBlock(bp)))); #endif erase(size, bp); //delete every adjacent block erase(getSize(getBlockHeader(getPrevBlock(bp))), getPrevBlock(bp)); erase(getSize(getBlockHeader(getNextBlock(bp))), getNextBlock(bp)); size += getSize(getBlockHeader(getNextBlock(bp))) + getSize(getBlockHeader(getPrevBlock(bp))); set(getBlockHeader(getPrevBlock(bp)), setMask(size, 0)); set(getBlockFooter(getNextBlock(bp)), setMask(size, 0)); push_back(size, getPrevBlock(bp)); //sum up return getPrevBlock(bp); } }
/* * Return cursor to beginning. */ void MemoryOArchive::clear() { if (!isAllocated()) { UTIL_THROW("Archive is not allocated"); } cursor_ = begin(); }
void evgSeqRam::enable() { if(isAllocated()) { BITSET32(m_pReg, SeqControl(m_id), EVG_SEQ_RAM_ARM); } else throw std::runtime_error("Trying to enable Unallocated seqRam"); }
//---------------------------------------------------------- void ofTexture::loadData(const ofFloatPixels & pix, int glFormat){ if(!isAllocated()){ allocate(pix.getWidth(), pix.getHeight(), ofGetGlInternalFormat(pix), ofGetUsingArbTex(), glFormat, ofGetGlType(pix)); } ofSetPixelStoreiAlignment(GL_UNPACK_ALIGNMENT,pix.getWidth(),pix.getBytesPerChannel(),ofGetNumChannelsFromGLFormat(glFormat)); loadData(pix.getData(), pix.getWidth(), pix.getHeight(), glFormat, ofGetGlType(pix)); }
/* tries to allocate new page with input pid. if pid is available, bitmask flag * is made. otherwise returns failure. The page is not only allocated in memory * and not written until later call */ RC_t BitmapPagedFile::allocatePageWithPID(PID_t pid) { if(pid >= NUM_BITS_HEADER) { // pid outside valid range return RC_OutOfRange; } // if pid is within range of current allocated pages if(pid < numContentPages) { if(isAllocated(pid)) { // pid already allocated return RC_AlreadyAllocated; } allocate(pid); return RC_OK; } // pid not in current page ranges, but within maximum page bounds /*int bytes = (pid - numContentPages)/8; for(; numContentPages < pid; numContentPages++) { // check this if(numContentPages%8 == 0) { header[numContentPages/8] = 0; } } */ numContentPages = pid + 1; allocate(pid); return RC_OK; }
void ofPixels_<PixelType>::setImageType(ofImageType imageType){ if(!isAllocated() || imageType==getImageType()) return; ofPixels_<PixelType> dst; dst.allocate(width,height,imageType); PixelType * dstPtr = &dst[0]; PixelType * srcPtr = &pixels[0]; int diffNumChannels = 0; if(dst.getNumChannels()<getNumChannels()){ diffNumChannels = getNumChannels()-dst.getNumChannels(); } for(int i=0;i<width*height;i++){ const PixelType & gray = *srcPtr; for(int j=0;j<dst.getNumChannels();j++){ if(j<getNumChannels()){ *dstPtr++ = *srcPtr++; }else if(j<3){ *dstPtr++ = gray; }else{ *dstPtr++ = ofColor_<PixelType>::limit(); } } srcPtr+=diffNumChannels; } swap(dst); }
//---------------------------------------------------------- ofPoint ofTexture::getCoordFromPoint(float xPos, float yPos) const{ ofPoint temp; if (!isAllocated()) return temp; #ifndef TARGET_OPENGLES if (texData.textureTarget == GL_TEXTURE_RECTANGLE_ARB){ temp.set(xPos, yPos); } else { #endif // non arb textures are 0 to 1, so we // (a) convert to a pct: float pctx = xPos / texData.width; float pcty = yPos / texData.height; // (b) mult by our internal pct (since we might not be 0-1 internally) pctx *= texData.tex_t; pcty *= texData.tex_u; temp.set(pctx, pcty); #ifndef TARGET_OPENGLES } #endif return temp; }
//============================================================================== AztecDVBR_Matrix::~AztecDVBR_Matrix(){ if (isAllocated()) { delete [] Amat_->val; delete [] Amat_->bindx; delete [] Amat_->rpntr; delete [] Amat_->bpntr; delete [] Amat_->indx; delete [] remoteInds_; delete [] remoteBlockSizes_; setAllocated(false); } if (isLoaded()) { free(Amat_->cpntr); free(external_); free(extern_index_); free(update_index_); free(data_org_); delete [] orderingUpdate_; setLoaded(false); } delete [] nnzPerRow_; localNNZ_ = 0; AZ_matrix_destroy(&Amat_); Amat_ = NULL; }
void AbstractAnalysisArrayData::valuesReady() { GMX_RELEASE_ASSERT(isAllocated(), "There must be some data"); if (bReady_) { return; } bReady_ = true; std::vector<AnalysisDataValue>::const_iterator valueIter = value_.begin(); AnalysisDataModuleManager &modules = moduleManager(); modules.notifyDataStart(this); for (int i = 0; i < rowCount(); ++i, valueIter += columnCount()) { AnalysisDataFrameHeader header(i, xvalue(i), 0); modules.notifyFrameStart(header); modules.notifyPointsAdd( AnalysisDataPointSetRef( header, pointSetInfo_, constArrayRefFromVector<AnalysisDataValue>(valueIter, valueIter + columnCount()))); modules.notifyFrameFinish(header); } modules.notifyDataFinish(); }
/* * Reset cursor to beginning, prepare to reread. */ void MemoryIArchive::reset() { if (!isAllocated()) { UTIL_THROW("Archive is not allocated"); } cursor_ = begin(); }
// return the value for the given alarm ID time_t TimeAlarmsClass::read(AlarmID_t ID) { if(isAllocated(ID)) return Alarm[ID].value ; else return dtINVALID_TIME; }
/* * Display debug info (1 line) */ void CChangeTrackerBase::displayTrackerInfo( const char *headerStr, const char *footerStrNotAllocd, NLMISC::CLog *log ) const { if ( isAllocated() ) log->displayNL( "%sAllocated, %d changes, smid %d mutid %d", headerStr, nbChanges(), smid(), mutid() ); else log->displayNL( "%sNot allocated%s", headerStr, footerStrNotAllocd ); }
// return the alarm type for the given alarm ID dtAlarmPeriod_t TimeAlarmsClass::readType(AlarmID_t ID) { if(isAllocated(ID)) return (dtAlarmPeriod_t)Alarm[ID].Mode.alarmType ; else return dtNotAllocated; }
//============================================================================== int AztecDVBR_Matrix::getBlockRow(int blkRow, double* val, int* blkColInds, int numNzBlks) const { if (!isAllocated()) return(1); int index; if (!inUpdate(blkRow, index)) { fei::console_out() << "AztecDVBR_Matrix::getBlockRow: ERROR: blkRow " << blkRow << " not in local update list." << FEI_ENDL; return(1); } //for each block, we need to find its block column index //in the bindx array, then go to that same position in the indx //array to find out how many point-entries are in that block. //We can then use the indx entry to go to the val array and get //the data. int nnzBlks = 0, nnzPts = 0; int err = getNumBlocksPerRow(blkRow, nnzBlks); if (err) return(err); err = getNumNonzerosPerRow(blkRow, nnzPts); if (err) return(err); if (numNzBlks != nnzBlks) return(1); int offset = 0; int blkCounter = 0; const int* blkUpdate = amap_->getBlockUpdate(); for(int indb = Amat_->bpntr[index]; indb<Amat_->bpntr[index+1]; indb++) { int numEntries = Amat_->indx[indb+1] - Amat_->indx[indb]; int valOffset = Amat_->indx[indb]; if (isLoaded()) { int ind = Amat_->bindx[indb]; if (ind < N_update_) { blkColInds[blkCounter++] = blkUpdate[orderingUpdate_[ind]]; } else { blkColInds[blkCounter++] = external_[ind-N_update_]; } } else { blkColInds[blkCounter++] = Amat_->bindx[indb]; } //ok, now we're ready to get the stuff. for(int i=0; i<numEntries; i++) { val[offset + i] = Amat_->val[valOffset + i]; } offset += numEntries; } return(0); }
static void* find_fit(size_t size) //find best place { #ifdef __DEBUG__ fprintf(stderr, "find fitting place - size : %d\n", size); #endif void* bp; void* s; size_t sizeIndex = size; for(s = getSegBySize(size); ; s = getSegBySize(sizeIndex)) //increase seg size { sizeIndex = getNextSize(sizeIndex); for(bp = s; ; bp = getNextNode(bp)) //iterate list { if(bp==NULL) break; #ifdef __DEBUG__ fprintf(stderr, "searching : %u / allocated? : %u / size? : %u\n", getBlockHeader(bp), isAllocated(getBlockHeader(bp)), getSize(getBlockHeader(bp))); #endif if(!isAllocated(getBlockHeader(bp)) && size <= getSize(getBlockHeader(bp))) { return bp; } if(isTail(bp)) break; } if(s==seg_inf) break; } return NULL; }
void TimeAlarmsClass::enable(AlarmID_t ID) { if(isAllocated(ID)) { Alarm[ID].Mode.isEnabled = (Alarm[ID].value != 0) && (Alarm[ID].onTickHandler != 0) ; // only enable if value is non zero and a tick handler has been set Alarm[ID].updateNextTrigger(); // trigger is updated whenever this is called, even if already enabled } }
int CIppImage::Alloc(IppiSize roi, int nchannels, int precision, int align) { int size; int du = (((precision & 255)+7)/8); int newStep = roi.width * nchannels * du; if(align) newStep += BYTES_PAD(roi.width, nchannels,du); if( isAllocated() && Height() == roi.height && Step() == newStep ) { m_roi = roi; m_nchannels = nchannels; m_precision = precision; m_step = newStep; return 0; } Free(); m_roi = roi; m_nchannels = nchannels; m_precision = precision; m_step = newStep; size = m_step * roi.height; m_imageData = (Ipp8u*)ippMalloc(size); m_allocated = m_imageData != 0; return m_imageData ? 0 : -1; } // CIppImage::Alloc()
// write the given value to the given alarm void TimeAlarmsClass::write(AlarmID_t ID, time_t value) { if(isAllocated(ID)) { Alarm[ID].value = value; enable(ID); // update trigger time } }
//---------------------------------------------------------- void ofTexture::loadData(const ofFloatPixels & pix){ if(!isAllocated()){ allocate(pix); }else{ ofSetPixelStoreiAlignment(GL_UNPACK_ALIGNMENT,pix.getBytesStride()); loadData(pix.getData(), pix.getWidth(), pix.getHeight(), ofGetGlFormat(pix), ofGetGlType(pix)); } }
void AbstractAnalysisArrayData::setColumnCount(int ncols) { GMX_RELEASE_ASSERT(!isAllocated(), "Cannot change column count after data has been allocated"); AbstractAnalysisData::setColumnCount(0, ncols); pointSetInfo_ = AnalysisDataPointSetInfo(0, ncols, 0, 0); }
Allocator::Result BitAllocator::allocate(Address addr) { if (addr < m_base || isAllocated(addr)) return InvalidAddress; m_array.set((addr - m_base) / m_chunkSize); return Success; }
//============================================================================== void AztecDVBR_Matrix::put(double s){ if (!isAllocated()) return; for(int i=0; i<localNNZ_; i++) { Amat_->val[i] = s; } return; }
// returns the number of allocated timers uint8_t TimeAlarmsClass::count() { uint8_t c = 0; for(uint8_t id = 0; id < dtNBR_ALARMS; id++) { if(isAllocated(id)) c++; } return c; }
void TimeAlarmsClass::free(AlarmID_t ID) { if(isAllocated(ID)) { Alarm[ID].Mode.isEnabled = false; Alarm[ID].Mode.alarmType = dtNotAllocated; Alarm[ID].onTickHandler = 0; Alarm[ID].value = 0; Alarm[ID].nextTrigger = 0; } }
void performcopy(AbstractImage& dest, int bytewidth, int height, int xoffset, int yoffset) const { assert(isAllocated()); const uint8_t *sourcedata = (uint8_t *) this->addr; uint8_t *destdata = (uint8_t *) dest.data(); for (int j=0;j<height;j++) { for (int i=0;i<bytewidth;i++) { destdata[j*bytewidth + i] = sourcedata[(j + yoffset) * this->row_stride + i + xoffset]; } } dest.setData(destdata); }
void ofxImageROI::setROI() { if (isAllocated()) { cornerPoints[0].set(0, 0); cornerPoints[1].set(this->width, 0); cornerPoints[2].set(this->width, this->height); cornerPoints[3].set(0, this->height); bSetROI = true; } }
//-------------------------------------------------------------- void ofVbo::VertexAttribute::setData(const float * attrib0x, int numCoords, int total, int usage, int stride, bool normalize){ if (!isAllocated()) { allocate(); } GLsizeiptr size = (stride == 0) ? numCoords * sizeof(float) : stride; this->stride = size; this->numCoords = numCoords; this->offset = 0; this->normalize = normalize; setData(total * size, attrib0x, usage); };
/* * Clear memory block (reset to empty state). */ void MemoryIArchive::clear() { if (!isAllocated()) { UTIL_THROW("Archive is not allocated"); } if (!ownsData_) { UTIL_THROW("Archive does not own data"); } cursor_ = begin(); end_ = begin(); }
bool evgSeqRam::alloc(evgSoftSeq* softSeq) { assert(softSeq); interruptLock ig; if(!isAllocated()) { softSeq->setSeqRam(this); m_softSeq = softSeq; return true; } else { return false; } }
RC_t BitmapPagedFile::disposePage(PID_t pid) { if(pid >= numContentPages) { return RC_OutOfRange; /* pid not within allocated pid range, nothing is done */ } if(isAllocated(pid)) { deallocate(pid); /* deallocates mapped bit in header, defers actual physical disposal of data until later */ return RC_OK; } return RC_NotAllocated; }