/* * convert malloced or non-malloced buffer to a Block. * used to build custom Block allocators. * * buf must be at least blocksize(usable) bytes. */ Block * mem2block(void *buf, ulong usable, int malloced) { Block *b; if(buf == nil) return nil; b = (Block *)buf; b->next = nil; b->list = nil; b->free = 0; b->flag = 0; b->ref = 0; b->magic = Bmagic; _xinc(&b->ref); /* align start of data portion by rounding up */ b->base = (uchar*)ALIGNUP((ulong)b + sizeof(Block)); /* align end of data portion by rounding down */ b->lim = (uchar*)b + (malloced? msize(b): blocksize(usable)); b->lim = (uchar*)((ulong)b->lim & ~(BLOCKALIGN-1)); /* leave sluff at beginning for added headers */ b->wp = b->rp = b->lim - ALIGNUP(usable); if(b->rp < b->base) panic("mem2block: b->rp < b->base"); if(b->lim > (uchar*)b + (malloced? msize(b): blocksize(usable))) panic("mem2block: b->lim beyond Block end"); return b; }
static void *debug_realloc (void *block, size_t size) { if (size == 0) { freeblock(block); return NULL; } else if (memdebug_total+size > memdebug_memlimit) return NULL; /* to test memory allocation errors */ else { size_t realsize = HEADER+size+MARKSIZE; char *newblock = (char *)(malloc)(realsize); /* alloc a new block */ int i; if (realsize < size) return NULL; /* overflow! */ if (newblock == NULL) return NULL; if (block) { size_t oldsize = *blocksize(block); if (oldsize > size) oldsize = size; memcpy(newblock+HEADER, block, oldsize); freeblock(block); /* erase (and check) old copy */ } memdebug_total += size; if (memdebug_total > memdebug_maxmem) memdebug_maxmem = memdebug_total; memdebug_numblocks++; *(unsigned long *)newblock = size; for (i=0;i<MARKSIZE;i++) *(newblock+HEADER+size+i) = (char)(MARK+i); return newblock+HEADER; } }
void *luaM_realloc (void *block, unsigned long size) { unsigned long realsize = HEADER+size+MARKSIZE; if (realsize != (size_t)realsize) lua_error("memory allocation error: block too big"); if (size == 0) { freeblock(block); return NULL; } else { char *newblock = malloc(realsize); int i; if (block) { unsigned long oldsize = *blocksize(block); if (oldsize > size) oldsize = size; memcpy(newblock+HEADER, block, oldsize); freeblock(block); /* erase (and check) old copy */ } if (newblock == NULL) lua_error(memEM); totalmem += size; numblocks++; *(unsigned long *)newblock = size; for (i=0;i<MARKSIZE;i++) *(newblock+HEADER+size+i) = MARK+i; return newblock+HEADER; } }
static void freeblock (void *block) { if (block) { size_t size = *blocksize(block); block = checkblock(block); memset(block, -1, size+HEADER+MARKSIZE); /* erase block */ (free)(block); /* free original block */ } }
Vpool::Vpool(size_t n, size_t expsz, double occ): origsz(n), realsz(roundup(n)), Block_pool_ATTLC(blocksize(roundup(n), expsz, occ)) { assert(origsz <= realsz); cnt = 0; avail = shrinkable = 0; totwaste = space_left = 0; prev_avail = 0; prev_space_left = 0; }
static void *checkblock (void *block) { unsigned long *b = blocksize(block); unsigned long size = *b; int i; for (i=0;i<MARKSIZE;i++) assert(*(((char *)b)+HEADER+size+i) == MARK+i); /* corrupted block? */ memdebug_numblocks--; memdebug_total -= size; return b; }
static void *checkblock (void *block) { if (block == NULL) return NULL; else { unsigned long *b = blocksize(block); unsigned long size = *b; int i; for (i=0;i<MARKSIZE;i++) LUA_ASSERT(*(((char *)b)+HEADER+size+i) == MARK+i, "corrupted block"); numblocks--; totalmem -= size; return b; } }
int main(int argc, char *argv[]){ struct stat buf; void *start; char *point; char *point1; if (argc != 3) { fprintf(stderr, "Error input \n"); exit(EXIT_FAILURE); } int imgfile = open(argv[1], O_RDONLY); char *filename=argv[2]; if (imgfile < 0){ fprintf(stderr, "Error no such file \n"); exit(EXIT_FAILURE); } fstat(imgfile, &buf); start = mmap(NULL, buf.st_size, PROT_READ, MAP_PRIVATE, imgfile, 0); if(start == MAP_FAILED) return; point=start; point1=start; block_size=blocksize(point); int rd_s=rds(point); int rd_b=rdb(point); int n=0; ss=block_size*rd_s; point=point+block_size*rd_s; while(point[0]!=0x00){ readfile(point); n++; point=point+64; } // printf("%d",n); getfile(point1,filename,n); //info end munmap(start, buf.st_size); close(imgfile); return 0; }
base& finish (void) { if (FINISH == mstate) return *this; if (ADD != mstate) reset (); mstate = FINISH; std::string kopad (mkey); std::size_t const blksize = blocksize (); for (std::size_t i = 0; i < blksize; ++i) kopad[i] ^= 0x5c; ohash.reset ().add (kopad).add (ihash.digest ()); return *this; }
base& reset () { std::size_t const blksize = blocksize (); if (mkey.size () > blksize) { HASH khash; mkey = khash.add(mkey).digest (); } if (mkey.size () < blksize) mkey.resize (blksize, 0); std::string kipad (mkey); for (std::size_t i = 0; i < blksize; ++i) kipad[i] ^= 0x36; ihash.reset ().add (kipad); mstate = ADD; return *this; }
int main(int argc, char *argv[]) { FILE *f; struct superblock sb; int i, len; char *block; if (argc < 3) { printf("Usage: %s <image file> <search string>\n", argv[0]); return 1; } f = fopen(argv[1], "r"); if (f == NULL) { perror("fopen"); return 1; } if (get_superblock(f, &sb)) return 1; block = malloc(blocksize(&sb)); if (block == NULL) return 1; // Search free blocks len = strlen(argv[2]); for (i = 0; i < sb.s_blocks_count; i++) { if (!is_block_free(&sb, i)) continue; if (get_block_data(&sb, i, block)) return 1; if (!strncmp(argv[2], block, len)) printf("%d\n", i); } free(block); fclose(f); return 0; }
/** * Load a single entry into a workspace * @param root :: The opened root node * @param entry_name :: The entry name * @param progressStart :: The percentage value to start the progress reporting for this entry * @param progressRange :: The percentage range that the progress reporting should cover * @returns A 2D workspace containing the loaded data */ API::Workspace_sptr LoadNexusProcessed::loadEntry(NXRoot & root, const std::string & entry_name, const double& progressStart, const double& progressRange) { progress(progressStart,"Opening entry " + entry_name + "..."); NXEntry mtd_entry = root.openEntry(entry_name); if (mtd_entry.containsGroup("table_workspace")) { return loadTableEntry(mtd_entry); } bool isEvent = false; std::string group_name = "workspace"; if (mtd_entry.containsGroup("event_workspace")) { isEvent = true; group_name = "event_workspace"; } // Get workspace characteristics NXData wksp_cls = mtd_entry.openNXData(group_name); // Axis information // "X" axis NXDouble xbins = wksp_cls.openNXDouble("axis1"); xbins.load(); std::string unit1 = xbins.attributes("units"); // Non-uniform x bins get saved as a 2D 'axis1' dataset int xlength(-1); if( xbins.rank() == 2 ) { xlength = xbins.dim1(); m_shared_bins = false; } else if( xbins.rank() == 1 ) { xlength = xbins.dim0(); m_shared_bins = true; xbins.load(); m_xbins.access().assign(xbins(), xbins() + xlength); } else { throw std::runtime_error("Unknown axis1 dimension encountered."); } // MatrixWorkspace axis 1 NXDouble axis2 = wksp_cls.openNXDouble("axis2"); std::string unit2 = axis2.attributes("units"); // The workspace being worked on API::MatrixWorkspace_sptr local_workspace; size_t nspectra; int64_t nchannels; // -------- Process as event ? -------------------- if (isEvent) { local_workspace = loadEventEntry(wksp_cls, xbins, progressStart, progressRange); nspectra = local_workspace->getNumberHistograms(); nchannels = local_workspace->blocksize(); } else { NXDataSetTyped<double> data = wksp_cls.openDoubleData(); nspectra = data.dim0(); nchannels = data.dim1(); //// validate the optional spectrum parameters, if set checkOptionalProperties(nspectra); // Actual number of spectra in output workspace (if only a range was going to be loaded) int total_specs=calculateWorkspacesize(nspectra); //// Create the 2D workspace for the output local_workspace = boost::dynamic_pointer_cast<API::MatrixWorkspace> (WorkspaceFactory::Instance().create("Workspace2D", total_specs, xlength, nchannels)); try { local_workspace->setTitle(mtd_entry.getString("title")); } catch (std::runtime_error&) { g_log.debug() << "No title was found in the input file, " << getPropertyValue("Filename") << std::endl; } // Set the YUnit label local_workspace->setYUnit(data.attributes("units")); std::string unitLabel = data.attributes("unit_label"); if (unitLabel.empty()) unitLabel = data.attributes("units"); local_workspace->setYUnitLabel(unitLabel); readBinMasking(wksp_cls, local_workspace); NXDataSetTyped<double> errors = wksp_cls.openNXDouble("errors"); int64_t blocksize(8); //const int fullblocks = nspectra / blocksize; //size of the workspace int64_t fullblocks = total_specs / blocksize; int64_t read_stop = (fullblocks * blocksize); const double progressBegin = progressStart+0.25*progressRange; const double progressScaler = 0.75*progressRange; int64_t hist_index = 0; int64_t wsIndex=0; if( m_shared_bins ) { //if spectrum min,max,list properties are set if(m_interval||m_list) { //if spectrum max,min properties are set read the data as a block(multiple of 8) and //then read the remaining data as finalblock if(m_interval) { //specs at the min-max interval int interval_specs=static_cast<int>(m_spec_max-m_spec_min); fullblocks=(interval_specs)/blocksize; read_stop = (fullblocks * blocksize)+m_spec_min-1; if(interval_specs<blocksize) { blocksize=total_specs; read_stop=m_spec_max-1; } hist_index=m_spec_min-1; for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, blocksize, nchannels, hist_index,wsIndex, local_workspace); } int64_t finalblock = m_spec_max-1 - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, finalblock, nchannels, hist_index,wsIndex,local_workspace); } } // if spectrum list property is set read each spectrum separately by setting blocksize=1 if(m_list) { std::vector<int64_t>::iterator itr=m_spec_list.begin(); for(;itr!=m_spec_list.end();++itr) { int64_t specIndex=(*itr)-1; progress(progressBegin+progressScaler*static_cast<double>(specIndex)/static_cast<double>(m_spec_list.size()),"Reading workspace data..."); loadBlock(data, errors, static_cast<int64_t>(1), nchannels, specIndex,wsIndex, local_workspace); } } } else { for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, blocksize, nchannels, hist_index,wsIndex, local_workspace); } int64_t finalblock = total_specs - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, finalblock, nchannels, hist_index,wsIndex,local_workspace); } } } else { if(m_interval||m_list) { if(m_interval) { int64_t interval_specs=m_spec_max-m_spec_min; fullblocks=(interval_specs)/blocksize; read_stop = (fullblocks * blocksize)+m_spec_min-1; if(interval_specs<blocksize) { blocksize=interval_specs; read_stop=m_spec_max-1; } hist_index=m_spec_min-1; for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, xbins, blocksize, nchannels, hist_index,wsIndex,local_workspace); } int64_t finalblock = m_spec_max-1 - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, xbins, finalblock, nchannels, hist_index,wsIndex, local_workspace); } } // if(m_list) { std::vector<int64_t>::iterator itr=m_spec_list.begin(); for(;itr!=m_spec_list.end();++itr) { int64_t specIndex=(*itr)-1; progress(progressBegin+progressScaler*static_cast<double>(specIndex)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, xbins, 1, nchannels, specIndex,wsIndex,local_workspace); } } } else { for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, xbins, blocksize, nchannels, hist_index,wsIndex,local_workspace); } int64_t finalblock = total_specs - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, xbins, finalblock, nchannels, hist_index,wsIndex, local_workspace); } } } } //end of NOT an event ------------------------------- //Units try { local_workspace->getAxis(0)->unit() = UnitFactory::Instance().create(unit1); //If this doesn't throw then it is a numeric access so grab the data so we can set it later axis2.load(); m_axis1vals = MantidVec(axis2(), axis2() + axis2.dim0()); } catch( std::runtime_error & ) { g_log.information() << "Axis 0 set to unitless quantity \"" << unit1 << "\"\n"; } // Setting a unit onto a SpectraAxis makes no sense. if ( unit2 == "TextAxis" ) { Mantid::API::TextAxis* newAxis = new Mantid::API::TextAxis(nspectra); local_workspace->replaceAxis(1, newAxis); } else if ( unit2 != "spectraNumber" ) { try { Mantid::API::NumericAxis* newAxis = new Mantid::API::NumericAxis(nspectra); local_workspace->replaceAxis(1, newAxis); newAxis->unit() = UnitFactory::Instance().create(unit2); } catch( std::runtime_error & ) { g_log.information() << "Axis 1 set to unitless quantity \"" << unit2 << "\"\n"; } } //Are we a distribution std::string dist = xbins.attributes("distribution"); if( dist == "1" ) { local_workspace->isDistribution(true); } else { local_workspace->isDistribution(false); } //Get information from all but data group std::string parameterStr; progress(progressStart+0.05*progressRange,"Reading the sample details..."); // Hop to the right point cppFile->openPath(mtd_entry.path()); try { // This loads logs, sample, and instrument. local_workspace->loadExperimentInfoNexus(cppFile, parameterStr); } catch (std::exception & e) { g_log.information("Error loading Instrument section of nxs file"); g_log.information(e.what()); } // Now assign the spectra-detector map readInstrumentGroup(mtd_entry, local_workspace); // Parameter map parsing progress(progressStart+0.11*progressRange,"Reading the parameter maps..."); local_workspace->readParameterMap(parameterStr); if ( ! local_workspace->getAxis(1)->isSpectra() ) { // If not a spectra axis, load the axis data into the workspace. (MW 25/11/10) loadNonSpectraAxis(local_workspace, wksp_cls); } progress(progressStart+0.15*progressRange,"Reading the workspace history..."); try { readAlgorithmHistory(mtd_entry, local_workspace); } catch (std::out_of_range&) { g_log.warning() << "Error in the workspaces algorithm list, its processing history is incomplete\n"; } progress(progressStart+0.2*progressRange,"Reading the workspace history..."); return boost::static_pointer_cast<API::Workspace>(local_workspace); }
int reader::init() { if (blocksize() != 512) return 0; tmpsect = new unsigned char[512]; return 1; }
static void freeblock (void *block) { if (block) memset(block, -1, *blocksize(block)); /* erase block */ free(checkblock(block)); }
static Block* _allocb(int size) { return mem2block(mallocz(blocksize(size), 0), size, 1); }
int main(void) { unsigned error; unsigned char* image; unsigned width, height; unsigned char* png; size_t pngsize; LodePNGState state; char filename[] = "handmaze.png"; /* NAME OF INPUT IMAGE */ lodepng_state_init(&state); /*optionally customize the state*/ state.info_raw.colortype = LCT_GREY; lodepng_load_file(&png, &pngsize, filename); error = lodepng_decode(&image, &width, &height, &state, png, pngsize); if(error) printf("error %u: %s\n", error, lodepng_error_text(error)); free(png); /*use image here*/ //printf("Width=%d Height=%d\n", width, height); //FILE * fp; //fp = fopen("imgout.txt", "w"); //fp = fopen("imgout.ram", "wb"); //int i,x,y; //char * ramimg = (char*) calloc(2*width*height, sizeof(char)); //for(i = 0; i < 2*width*height; i++){ //fprintf(fp, "%d (%d,%d)=%d\n", i, i%width, i/width, image[i]); // if(i%2 == 0) // ramimg[i] = image[i/2]; // else // ramimg[i] = 0; //} //fwrite(ramimg, sizeof(unsigned char), 2*width*height, fp); //free(ramimg); //fclose(fp); //for(y = 0; y < height; y++) { // for(x = 0; x < width; x++) { // fprintf(fp, "(%d,%d)=%d\n", x, y, image[coords(x,y,width,height)]); // } //} unsigned char * gaussimg = (unsigned char*) calloc(width*height, sizeof(char)); unsigned char * outimg = (unsigned char*) calloc(width*height, sizeof(char)); gaussian_blur(width, height, image, gaussimg); sobel_filtering(width, height, gaussimg, outimg); int right_coord, startx, starty, index1=6, index2=5; int block_size =blocksize(width, height, image, &startx, &starty, 7, &right_coord, index1, index2); //printf("blocksize = %d\n", block_size); int solver; unsigned char path[144]; int *size=(int *) malloc(sizeof(int)); *size = 0; solver = dfs(width,height,image, startx, starty, startx, starty, block_size, path, size); //printf("size = %d\n", *size); int i1; for(i1 = *size; i1 >= 0; i1--) { printf("%c\n", path[i1]); } //int x, y; //for(x = 0; x < width; x++) //{ // for(y = 0; y < height; y++) // { // outimg[coords(x,y,width,height)] = image[coords(x,y,width,height)]; // } //} unsigned char* outpng; error = lodepng_encode(&outpng, &pngsize, outimg, width, height, &state); if(!error) lodepng_save_file(outpng, pngsize, "sobel.png"); /* NAME OF OUTPUT IMAGE */ if(error) printf("error %u: %s\n", error, lodepng_error_text(error)); /* CLEANUP */ lodepng_state_cleanup(&state); free(image); free(outimg); return 0; }
int main(int argc, char ** argv) { SETLOGMASK(); { TEST(); ASSERT(diminuto_shaper_bursttolerance(2, 3, 7, 5) == 23); ASSERT(diminuto_shaper_bursttolerance(2, 0, 7, 5) == 20); ASSERT(diminuto_shaper_bursttolerance(0, 0, 2, 5) == 8); ASSERT(diminuto_shaper_bursttolerance(7, 3, 7, 5) == 3); ASSERT(diminuto_shaper_bursttolerance(2, 3, 7, 1) == 3); ASSERT(diminuto_shaper_bursttolerance(2, 3, 7, 0) == 3); STATUS(); } { static const size_t PEAK = 2048; static const diminuto_ticks_t TOLERANCE = 0; static const size_t SUSTAINED = 1024; static const size_t BURST = 512; static const size_t OPERATIONS = 1000000; diminuto_shaper_t shaper; diminuto_shaper_t * sp; size_t size = 0; diminuto_ticks_t now = 0; diminuto_ticks_t delay; size_t iops; int admissable; uint64_t total = 0; diminuto_ticks_t duration = 0; double peak = 0.0; double sustained; double rate; diminuto_ticks_t frequency; diminuto_ticks_t peakincrement; diminuto_ticks_t jittertolerance; diminuto_ticks_t sustainedincrement; diminuto_ticks_t bursttolerance; /**/ frequency = diminuto_frequency(); /**/ peakincrement = diminuto_throttle_interarrivaltime(PEAK, 1, frequency); jittertolerance = diminuto_throttle_jittertolerance(peakincrement, BURST) + TOLERANCE; sustainedincrement = diminuto_throttle_interarrivaltime(SUSTAINED, 1, frequency); bursttolerance = diminuto_shaper_bursttolerance(peakincrement, jittertolerance, sustainedincrement, BURST); /**/ sp = diminuto_shaper_init(&shaper, peakincrement, 0 /* jittertolerance */, sustainedincrement, bursttolerance, now); ASSERT(sp == &shaper); diminuto_shaper_log(sp); srand(diminuto_time_clock()); /**/ for (iops = 0; iops < OPERATIONS; ++iops) { delay = diminuto_shaper_request(sp, now); ASSERT(delay >= 0); now += delay; duration += delay; if (iops <= 0) { /* Do nothing. */ } else if (delay <= 0) { /* Do nothing. */ } else { rate = size; rate *= frequency; rate /= delay; if (rate > peak) { peak = rate; } } delay = diminuto_shaper_request(sp, now); ASSERT(delay == 0); size = blocksize(BURST); ASSERT(size > 0); ASSERT(size <= BURST); total += size; admissable = !diminuto_shaper_commitn(sp, size); ASSERT(admissable); } /**/ delay = diminuto_shaper_getexpected(sp); ASSERT(delay >= 0); now += delay; duration += delay; if (delay > 0) { rate = size; rate *= frequency; rate /= delay; if (rate > peak) { peak = rate; } } diminuto_shaper_update(sp, now); /**/ ASSERT(total > 0); ASSERT(duration > frequency); diminuto_shaper_log(sp); sustained = total; sustained *= frequency; sustained /= duration; DIMINUTO_LOG_DEBUG("operations=%zu total=%llubytes average=%llubytes duration=%lldseconds peak=%zubytes/second measured=%lfbytes/second sustained=%zubytes/second measured=%lfdbytes/second\n", iops, total, total / iops, duration / diminuto_frequency(), PEAK, peak, SUSTAINED, sustained); ASSERT(fabs(sustained - SUSTAINED) < (SUSTAINED / 200) /* 0.5% */); ADVISE(fabs(peak - PEAK) < (PEAK / 200) /* 0.5% */); } EXIT(); }