/*
* 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();
}
