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);
}
