void quick_sort(void *base, size_t num, size_t size, CMP_FUNC cmpf, SWAP_FUNC swapf) { __dump(base, num, size); __quick_sort(base, num, size, cmpf, swapf); __dump(base, num, size); __verify(base, num, size, cmpf); }
static ssize_t __read(void *userdata, void *buffer, size_t len) { coolmic_iobuffer_t *self = userdata; size_t end; /* If reader > writer: we can read up to size-1. * Else: we can read up till writer-1 */ if (self->reader > self->writer) { end = self->size; } else { end = self->writer; } if (len > (end - self->reader)) { len = end - self->reader; } __dump(self, "__read"); memcpy(buffer, self->content + self->reader, len); self->reader += len; if (self->reader == self->size) self->reader = 0; return len; }
void vars_dump(struct vars *vars) { int i; for (i = 0; i <= vars->cur; i++) { fprintf(stderr, "VARS DUMP scope %d @ %p\n", i, vars->scopes[i]); __dump(vars->scopes[i], INDENT); } }
void merge_sort(void *base, size_t num, size_t size, CMP_FUNC cmpf, SWAP_FUNC swapf) { unsigned int i, c, step=1; __assert(base && cmpf); if (!swapf) swapf = (size == 4 ? __swap : swap_dft); __dump(base, num, size); while (step < num) { for(i = 0; i < num; i += 2*step) { c = (i+2*step)>num?num-i:step*2; __merge((char*)base+i*size, c, size, step-1, cmpf, swapf); } step *= 2; } __dump(base, num, size); __verify(base, num, size, cmpf); }
void shell_sort(void *base, size_t num, size_t size, CMP_FUNC cmpf, SWAP_FUNC swapf) { unsigned int s = num; __assert(base && cmpf); if (!swapf) swapf = (size == 4 ? __swap : swap_dft); __dump(base, num, size); while ((s=(s)>>1) >= 1) { __shell_once(base, num, size, cmpf, swapf, (s&0x01)?s:s+1); } __verify(base, num, size, cmpf); }
static void __dump(struct clog_cfg_block* block) { if (block) { if (block->branch) printf("%u -> %u;\n",block->gen,block->branch->gen); if (block->fallthru) printf("%u -> %u;\n",block->gen,block->fallthru->gen); __dump(block->a_next); } }
static void __dump_nvlist_array(nvpair_t *pair, int indent) { nvlist_t **out; uint_t nout; uint_t i; int ret; ret = nvpair_value_nvlist_array(pair, &out, &nout); ASSERT0(ret); fprintf(stderr, " items=%u\n", nout); for (i = 0; i < nout; i++) { fprintf(stderr, "%*s%u:\n", indent, "", i); __dump(out[i], indent + INDENT); } }
/* This function is to iterate. It will try to fill the ring buffer. * If the input is non-blocking this will also be non-blocking. */ int coolmic_iobuffer_iter(coolmic_iobuffer_t *self) { ssize_t ret; size_t end; size_t len; /* check if we have a valid object */ if (!self) return COOLMIC_ERROR_FAULT; if (!self->io) return COOLMIC_ERROR_INVAL; /* Now calculate the amount of data to read and the used address space. */ if (self->reader > self->writer) { end = self->reader - 1; } else if (self->reader) { end = self->size; } else { end = self->size - 1; } len = end - self->writer; if (!len) return COOLMIC_ERROR_BUSY; /* avoid huge reads */ if (len > 8192) len = 8192; ret = coolmic_iohandle_read(self->io, self->content + self->writer, len); __dump(self, "iter"); if (ret < 0) { return COOLMIC_ERROR_GENERIC; } else if (ret == 0) { return COOLMIC_ERROR_NONE; } self->writer += ret; if (self->writer == self->size) self->writer = 0; return COOLMIC_ERROR_NONE; }
int clog_cfg_construct(const struct clog_ast_block* ast_block) { struct clog_cfg_context context = {0}; struct clog_cfg_block* block; if (!clog_cfg_alloc_block(NULL,&block)) return 0; if (!clog_cfg_construct_block(block,ast_block,&context)) { return 0; } printf("digraph cfg {\n"); __dump(block); printf("}"); return 1; }
static void __dump(nvlist_t *list, int indent) { nvpair_t *pair; for (pair = nvlist_next_nvpair(list, NULL); pair; pair = nvlist_next_nvpair(list, pair)) { fprintf(stderr, "%*sname='%s' type=%d", indent, "", nvpair_name(pair), nvpair_type(pair)); switch (nvpair_type(pair)) { case DATA_TYPE_STRING: fprintf(stderr, "\n%*svalue='%s'\n", indent + INDENT, "", pair2str(pair)); break; case DATA_TYPE_STRING_ARRAY: __dump_string_array(pair, indent + INDENT); break; case DATA_TYPE_BOOLEAN_VALUE: fprintf(stderr, "\n%*svalue=%s\n", indent + INDENT, "", pair2bool(pair) ? "true" : "false"); break; case DATA_TYPE_UINT8: fprintf(stderr, "\n%*svalue='%c'\n", indent + INDENT, "", pair2char(pair)); break; case DATA_TYPE_UINT64: fprintf(stderr, "\n%*svalue=%"PRIu64"\n", indent + INDENT, "", pair2int(pair)); break; case DATA_TYPE_NVLIST: fprintf(stderr, "\n"); __dump(pair2nvl(pair), indent + INDENT); break; case DATA_TYPE_NVLIST_ARRAY: __dump_nvlist_array(pair, indent + INDENT); break; default: fprintf(stderr, "\n"); break; } } }
static void __shell_once(void *base, size_t num, size_t size, CMP_FUNC cmpf, SWAP_FUNC swapf, unsigned int scale) { unsigned int i, j, c, d, q=0; //printf("---> scale : %d \n", scale); while (q < scale) { for (i = q+scale; i < num; i = i+scale){ for (j = i; j >= scale; j = j-scale){ c = j*size; d = scale*size; if (cmpf((char*)base+c, (char*)base+c-d) < 0) swapf((char*)base+c, (char*)base+c-d, size); else break; } } q++; } __dump(base, num, size); }
static int __eof(void *userdata) { coolmic_iobuffer_t *self = userdata; /* Check if there is still data in the buffer. * If so it can not be eof. */ __dump(self, "__eof"); if (self->reader != self->writer) return COOLMIC_ERROR_NONE; /* There is no data in the buffer. If we do not have an IO handle this is EOF. */ if (!self->io) return 1; /* We have no data in the buffer but an IO handle. Just forward the question to the next layer. */ return coolmic_iohandle_eof(self->io); }
void nvl_dump(nvlist_t *nvl) { fprintf(stderr, "nvlist dump @ %p\n", nvl); __dump(nvl, INDENT); }