lib/silcutil/silcstack.c

   1 /*
   2
   3   silcstack.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2003 - 2007 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 #include "silc.h"
  21
  22 /************************** Types and definitions ***************************/
  23
  24 /* The SilcStack context */
  25 struct SilcStackStruct {
  26   SilcStack parent;                           /* Parent stack */
  27   SilcMutex lock;                             /* Stack lock */
  28   SilcList stacks;                            /* List of stacks for childs */
  29   SilcStackDataEntry stack;                   /* The allocated stack */
  30   SilcStackFrame *frames;                     /* Allocated stack frames */
  31   SilcStackFrame *frame;                      /* Current stack frame */
  32   SilcStackOomHandler oom_handler;            /* OOM handler */
  33   void *oom_context;                          /* OOM handler context */
  34   SilcUInt32 stack_size;                      /* Default stack size */
  35   SilcUInt32 alignment;                       /* Memory alignment */
  36 #ifdef SILC_DIST_INPLACE
  37   /* Statistics */
  38   SilcUInt32 snum_malloc;
  39   SilcUInt32 sbytes_malloc;
  40   SilcUInt32 snum_errors;
  41 #endif /* SILC_DIST_INPLACE */
  42 };
  43
  44 /************************ Static utility functions **************************/
  45
  46 /* Compute stack block index for the `size'. */
  47
  48 static SilcUInt32 silc_stack_get_index(SilcUInt32 size, SilcUInt32 *ret_bsize)
  49 {
  50   SilcUInt32 bsize, si;
  51
  52   if (size < SILC_STACK_DEFAULT_SIZE)
  53     size = SILC_STACK_DEFAULT_SIZE;
  54   si = 0;
  55   bsize = SILC_STACK_DEFAULT_SIZE;
  56   while (bsize < size) {
  57     bsize <<= 1;
  58     si++;
  59   }
  60
  61   *ret_bsize = bsize;
  62
  63   return si;
  64 }
  65
  66 /* Get stack from `stack' or allocate new one. */
  67
  68 static SilcStackDataEntry silc_stack_ref_stack(SilcStack stack,
  69                                                SilcUInt32 size,
  70                                                SilcUInt32 *ret_si,
  71                                                SilcUInt32 *ret_bsize)
  72 {
  73   SilcStackDataEntry e;
  74   SilcUInt32 si, bsize;
  75
  76   /* Get stack block index and block size for requested size */
  77   si = silc_stack_get_index(size, &bsize);
  78   *ret_si = si;
  79   *ret_bsize = bsize;
  80
  81   SILC_ST_DEBUG(("Get stack block, si %d, size %lu, stack %p",
  82                  si, bsize, stack));
  83
  84   silc_mutex_lock(stack->lock);
  85
  86   /* Get stack that has block that can house our size requirement. */
  87   silc_list_start(stack->stacks);
  88   while ((e = silc_list_get(stack->stacks))) {
  89     if (!e->data[si])
  90       continue;
  91
  92     silc_list_del(stack->stacks, e);
  93     SILC_ST_DEBUG(("Got stack blocks %p from stack %p", e->data, stack));
  94     silc_mutex_unlock(stack->lock);
  95     return e;
  96   }
  97
  98   silc_mutex_unlock(stack->lock);
  99
 100   /* If we are child, get block from parent */
 101   if (stack->parent)
 102     return silc_stack_ref_stack(stack->parent, size, ret_si, ret_bsize);
 103
 104   SILC_ST_DEBUG(("Allocate new stack blocks"));
 105
 106   /* Allocate new stack blocks */
 107   e = silc_calloc(1, sizeof(*e));
 108   if (!e)
 109     return NULL;
 110   e->data[si] = silc_malloc(bsize + SILC_STACK_ALIGN(sizeof(*e->data[0]),
 111                                                      stack->alignment));
 112   if (!e->data[si]) {
 113     silc_free(e);
 114     return NULL;
 115   }
 116   e->data[si]->bytes_left = bsize;
 117   e->si = si;
 118   e->bsize = bsize;
 119
 120   SILC_ST_DEBUG(("Got stack blocks %p from stack %p", e->data, stack));
 121
 122   return e;
 123 }
 124
 125 /* Return the `data' back to the `stack'. */
 126
 127 static void silc_stack_unref_stack(SilcStack stack, SilcStackDataEntry e)
 128 {
 129   int i;
 130
 131   SILC_LOG_DEBUG(("Release stack blocks %p to stack %p, si %d",
 132                   e->data, stack, e->si));
 133
 134   /* Release all blocks from allocations */
 135   for (i = e->si; i < SILC_STACK_BLOCK_NUM; i++) {
 136     if (!e->data[i])
 137       continue;
 138     if (!i)
 139       e->data[i]->bytes_left = e->bsize;
 140     else
 141       e->data[i]->bytes_left = SILC_STACK_BLOCK_SIZE(stack, i);
 142   }
 143
 144   silc_mutex_lock(stack->lock);
 145   silc_list_add(stack->stacks, e);
 146   silc_mutex_unlock(stack->lock);
 147 }
 148
 149 /* Allocate memory from a specific stack block */
 150
 151 static void *silc_stack_alloc_block(SilcStack stack, SilcStackDataEntry e,
 152                                     SilcUInt32 items, SilcUInt32 size)
 153 {
 154   SilcUInt32 asize;
 155   void *ptr;
 156
 157   /* Get pointer and consume the stack block */
 158   asize = SILC_STACK_ALIGN(items * size, stack->alignment);
 159   ptr = SILC_STACK_DATA_EXT(e->data, e->si, e->bsize, stack->alignment);
 160   e->data[e->si]->bytes_left -= asize;
 161   memset(ptr, 0, items * size);
 162
 163   return ptr;
 164 }
 165
 166 /***************************** SilcStack API ********************************/
 167
 168 /* Allocate the stack */
 169
 170 SilcStack silc_stack_alloc(SilcUInt32 stack_size, SilcStack parent)
 171 {
 172   SilcStack stack;
 173   SilcStackDataEntry e;
 174   SilcUInt32 si = 0, bsize = 0;
 175
 176   stack_size = stack_size ? stack_size : SILC_STACK_DEFAULT_SIZE;
 177   if (stack_size < SILC_STACK_DEFAULT_SIZE)
 178     stack_size = SILC_STACK_DEFAULT_SIZE;
 179
 180   if (parent) {
 181     /* Get stack from parent.  The stack itself is allocated from the
 182        parent (but does not consume parent's own stack). */
 183     e = silc_stack_ref_stack(parent, stack_size, &si, &bsize);
 184     if (!e)
 185       return NULL;
 186
 187     /* Allocate stack from the returned stack.  We allocate ourselves from
 188        our own stack. */
 189     stack = silc_stack_alloc_block(parent, e, 1, sizeof(*stack));
 190     if (!stack) {
 191       silc_stack_unref_stack(parent, e);
 192       return NULL;
 193     }
 194
 195     stack->parent = parent;
 196     stack->stack_size = stack_size;
 197     stack->alignment = SILC_STACK_DEFAULT_ALIGN;
 198     stack->oom_handler = parent->oom_handler;
 199     stack->oom_context = parent->oom_context;
 200     stack->lock = parent->lock;
 201     silc_list_init(stack->stacks, struct SilcStackDataEntryStruct, next);
 202
 203     /* Allocate stack frames from the stack itself */
 204     stack->frames = silc_stack_alloc_block(stack, e, SILC_STACK_BLOCK_NUM,
 205                                            sizeof(*stack->frames));
 206     if (!stack->frames) {
 207       silc_stack_unref_stack(parent, e);
 208       return NULL;
 209     }
 210
 211     /* Set the initial stack */
 212     stack->stack = e;
 213   } else {
 214     /* Dynamically allocate new stack */
 215     stack = silc_calloc(1, sizeof(*stack));
 216     if (!stack)
 217       return NULL;
 218
 219     stack->stack_size = stack_size;
 220     stack->alignment = SILC_STACK_DEFAULT_ALIGN;
 221     silc_list_init(stack->stacks, struct SilcStackDataEntryStruct, next);
 222
 223     /* Create initial stack */
 224     stack->stack = silc_calloc(1, sizeof(*stack->stack));
 225     if (!stack->stack) {
 226       silc_free(stack);
 227       return NULL;
 228     }
 229     stack->stack->data[0] =
 230       silc_malloc(stack->stack_size +
 231                   SILC_STACK_ALIGN(sizeof(*stack->stack->data[0]),
 232                                    stack->alignment));
 233     if (!stack->stack->data[0]) {
 234       silc_free(stack->stack);
 235       silc_free(stack);
 236       return NULL;
 237     }
 238     stack->stack->data[0]->bytes_left = stack->stack_size;
 239     stack->stack->si = 0;
 240     stack->stack->bsize = stack->stack_size;
 241
 242     /* Allocate stack frames from the stack itself */
 243     stack->frames = silc_stack_alloc_block(stack, stack->stack,
 244                                            SILC_STACK_DEFAULT_NUM,
 245                                            sizeof(*stack->frames));
 246     if (!stack->frames) {
 247       silc_free(stack->stack->data[0]);
 248       silc_free(stack->stack);
 249       silc_free(stack);
 250       return NULL;
 251     }
 252
 253     /* Allocate lock */
 254     silc_mutex_alloc(&stack->lock);
 255   }
 256
 257   /* Use the allocated stack in first stack frame */
 258   stack->frame = &stack->frames[0];
 259   stack->frame->prev = NULL;
 260   stack->frame->bytes_used = stack->stack_size;
 261   stack->frame->sp = 1;
 262   stack->frame->si = si;
 263
 264   SILC_LOG_DEBUG(("New stack %p, size %d bytes", stack, stack->stack_size));
 265
 266   return stack;
 267 }
 268
 269 /* Frees the stack and all allocated memory */
 270
 271 void silc_stack_free(SilcStack stack)
 272 {
 273   SilcStackDataEntry e;
 274   int i;
 275
 276   if (!stack)
 277     return;
 278
 279   SILC_LOG_DEBUG(("Free stack %p", stack));
 280
 281   if (!stack->parent) {
 282     silc_list_start(stack->stacks);
 283     while ((e = silc_list_get(stack->stacks))) {
 284       for (i = 0; i < SILC_STACK_BLOCK_NUM; i++)
 285         silc_free(e->data[i]);
 286       silc_free(e);
 287     }
 288
 289     for (i = 0; i < SILC_STACK_BLOCK_NUM; i++)
 290       silc_free(stack->stack->data[i]);
 291     silc_free(stack->stack);
 292
 293     if (stack->lock)
 294       silc_mutex_free(stack->lock);
 295
 296     silc_free(stack);
 297   } else {
 298     /* Return all stack blocks to the parent */
 299     silc_list_start(stack->stacks);
 300     while ((e = silc_list_get(stack->stacks)))
 301       silc_stack_unref_stack(stack->parent, e);
 302
 303     silc_stack_unref_stack(stack->parent, stack->stack);
 304   }
 305 }
 306
 307 /* Push to next stack frame */
 308
 309 SilcUInt32 silc_stack_push(SilcStack stack, SilcStackFrame *frame)
 310 {
 311   if (!stack)
 312     return 0;
 313
 314   if (!frame) {
 315     if (stack->frame->sp >= SILC_STACK_ALIGN(stack->frame->sp,
 316                                              SILC_STACK_DEFAULT_NUM)) {
 317       SILC_LOG_DEBUG(("SilcStack %p running out of frames, cannot push",
 318                       stack));
 319       return stack->frame->sp;
 320     }
 321
 322     frame = &stack->frames[stack->frame->sp];
 323   }
 324
 325   /* Push */
 326   frame->prev = stack->frame;
 327   frame->sp = stack->frame->sp + 1;
 328   frame->si = stack->frame->si;
 329   frame->bytes_used = stack->stack->data[frame->si]->bytes_left;
 330   stack->frame = frame;
 331
 332   SILC_ST_DEBUG(("Push %p: sp %d -> %d, si %d", stack, frame->prev->sp,
 333                  frame->sp, frame->si));
 334
 335   return stack->frame->sp;
 336 }
 337
 338 /* Pop to previous stack frame */
 339
 340 SilcUInt32 silc_stack_pop(SilcStack stack)
 341 {
 342   SilcUInt32 si;
 343
 344   if (!stack || !stack->frame->prev)
 345     return 0;
 346
 347   /* Pop */
 348   si = stack->frame->si;
 349   while (si > stack->frame->prev->si) {
 350     if (stack->stack->data[si])
 351       stack->stack->data[si]->bytes_left = SILC_STACK_BLOCK_SIZE(stack, si);
 352     si--;
 353   }
 354   stack->stack->data[si]->bytes_left = stack->frame->bytes_used;
 355   stack->frame = stack->frame->prev;
 356
 357   SILC_ST_DEBUG(("Pop %p: sp %d -> %d, si %d", stack, stack->frame->sp + 1,
 358                  stack->frame->sp, stack->frame->si));
 359
 360   return stack->frame->sp + 1;
 361 }
 362
 363 /* Allocate memory.  Returns pointer to the memory or NULL on error. */
 364
 365 void *silc_stack_malloc(SilcStack stack, SilcUInt32 size)
 366 {
 367   void *ptr;
 368   SilcUInt32 bsize, bsize2;
 369   SilcUInt32 si = stack->frame->si;
 370
 371   SILC_STACK_STAT(stack, num_malloc, 1);
 372   SILC_ST_DEBUG(("Allocating %d bytes from %p", size, stack));
 373
 374   if (silc_unlikely(!size)) {
 375     SILC_LOG_ERROR(("Allocation by zero (0)"));
 376     SILC_STACK_STAT(stack, num_errors, 1);
 377     return NULL;
 378   }
 379
 380   if (silc_unlikely(size > SILC_STACK_MAX_ALLOC)) {
 381     SILC_LOG_ERROR(("Allocating too much"));
 382     SILC_STACK_STAT(stack, num_errors, 1);
 383     if (stack->oom_handler)
 384       stack->oom_handler(stack, stack->oom_context);
 385     return NULL;
 386   }
 387
 388   /* Align properly  */
 389   size = SILC_STACK_ALIGN(size, stack->alignment);
 390
 391   /* Compute the size of current stack block */
 392   bsize = SILC_STACK_BLOCK_SIZE(stack, si);
 393
 394   /* See if there is space in the current stack block */
 395   if (stack->stack->data[si]->bytes_left >= size) {
 396     /* Get pointer to the memory */
 397     ptr = SILC_STACK_DATA(stack, si, bsize);
 398     stack->stack->data[si]->bytes_left -= size;
 399     SILC_STACK_STAT(stack, bytes_malloc, size);
 400     return ptr;
 401   }
 402
 403   /* There is not enough space in this block.  Find the spot to stack
 404      block that can handle this size memory. */
 405   if (bsize < SILC_STACK_DEFAULT_SIZE)
 406     bsize = SILC_STACK_DEFAULT_SIZE;
 407   bsize += size;
 408   bsize2 = SILC_STACK_DEFAULT_SIZE;
 409   si = 0;
 410   while (bsize2 < bsize) {
 411     bsize2 <<= 1;
 412     si++;
 413   }
 414   if (silc_unlikely(si >= SILC_STACK_BLOCK_NUM)) {
 415     SILC_LOG_ERROR(("Allocating too large block"));
 416     SILC_STACK_STAT(stack, num_errors, 1);
 417     if (stack->oom_handler)
 418       stack->oom_handler(stack, stack->oom_context);
 419     return NULL;
 420   }
 421
 422   /* Allocate the block if it doesn't exist yet */
 423   if (!stack->stack->data[si]) {
 424     SILC_ST_DEBUG(("Allocating new stack block, %d bytes", bsize2));
 425     stack->stack->data[si] =
 426       silc_malloc(bsize2 +
 427                   SILC_STACK_ALIGN(sizeof(**stack->stack->data),
 428                                    stack->alignment));
 429     if (silc_unlikely(!stack->stack->data[si])) {
 430       SILC_STACK_STAT(stack, num_errors, 1);
 431       if (stack->oom_handler)
 432         stack->oom_handler(stack, stack->oom_context);
 433       return NULL;
 434     }
 435     stack->stack->data[si]->bytes_left = bsize2;
 436   }
 437
 438   /* Now return memory from this new block.  It is guaranteed that in this
 439      block there is enough space for this memory. */
 440   assert(stack->stack->data[si]->bytes_left >= size);
 441   ptr = SILC_STACK_DATA(stack, si, bsize2);
 442   stack->stack->data[si]->bytes_left -= size;
 443   stack->frame->si = si;
 444   SILC_STACK_STAT(stack, bytes_malloc, size);
 445
 446   return ptr;
 447 }
 448
 449 /* Attempts to reallocate memory by changing the size of the `ptr' into
 450    `size'.  This routine works only if the previous allocation to `stack'
 451    was `ptr'.  If there is another memory allocation between allocating
 452    `ptr' and this call this routine will return NULL.  NULL is also returned
 453    if the `size' does not fit into the current block.  If NULL is returned
 454    the old memory remains intact. */
 455
 456 void *silc_stack_realloc(SilcStack stack, SilcUInt32 old_size,
 457                          void *ptr, SilcUInt32 size)
 458 {
 459   SilcUInt32 si = stack->frame->si;
 460   SilcUInt32 bsize;
 461   void *sptr;
 462
 463   if (!ptr)
 464     return silc_stack_malloc(stack, size);
 465
 466   SILC_STACK_STAT(stack, num_malloc, 1);
 467   SILC_ST_DEBUG(("Reallocating %d bytes (%d) from %p", size, old_size, stack));
 468
 469   if (silc_unlikely(!size || !old_size)) {
 470     SILC_LOG_ERROR(("Allocation by zero (0)"));
 471     SILC_STACK_STAT(stack, num_errors, 1);
 472     return NULL;
 473   }
 474
 475   if (silc_unlikely(size > SILC_STACK_MAX_ALLOC)) {
 476     SILC_LOG_ERROR(("Allocating too much"));
 477     SILC_STACK_STAT(stack, num_errors, 1);
 478     if (stack->oom_handler)
 479       stack->oom_handler(stack, stack->oom_context);
 480     return NULL;
 481   }
 482
 483   /* Align properly */
 484   old_size = SILC_STACK_ALIGN(old_size, stack->alignment);
 485
 486   /* Compute the size of current stack block */
 487   bsize = SILC_STACK_BLOCK_SIZE(stack, si);
 488
 489   /* Check that `ptr' is last allocation */
 490   sptr = (unsigned char *)stack->stack->data[si] +
 491     SILC_STACK_ALIGN(sizeof(**stack->stack->data), stack->alignment);
 492   if (stack->stack->data[si]->bytes_left + old_size +
 493       ((unsigned char *)ptr - (unsigned char *)sptr) != bsize) {
 494     SILC_LOG_DEBUG(("Cannot reallocate"));
 495     SILC_STACK_STAT(stack, num_errors, 1);
 496     return NULL;
 497   }
 498
 499   /* Now check that the new size fits to this block */
 500   if (stack->stack->data[si]->bytes_left >= size) {
 501     /* It fits, so simply return the old pointer */
 502     size = SILC_STACK_ALIGN(size, stack->alignment);
 503     stack->stack->data[si]->bytes_left -= (size - old_size);
 504     SILC_STACK_STAT(stack, bytes_malloc, (size - old_size));
 505     return ptr;
 506   }
 507
 508   SILC_LOG_DEBUG(("Cannot reallocate in this block"));
 509   SILC_STACK_STAT(stack, num_errors, 1);
 510   return NULL;
 511 }
 512
 513 /* Set OOM handler */
 514
 515 void silc_stack_set_oom_handler(SilcStack stack,
 516                                 SilcStackOomHandler oom_handler,
 517                                 void *context)
 518 {
 519   stack->oom_handler = oom_handler;
 520   stack->oom_context = context;
 521 }
 522
 523 /* Set default alignment */
 524
 525 void silc_stack_set_alignment(SilcStack stack, SilcUInt32 alignment)
 526 {
 527   SILC_LOG_DEBUG(("Set stack %p alignment to %d bytes", stack, alignment));
 528   stack->alignment = alignment;
 529 }
 530
 531 /* Get default alignment */
 532
 533 SilcUInt32 silc_stack_get_alignment(SilcStack stack)
 534 {
 535   return stack->alignment;
 536 }
 537
 538 /* Purge stack */
 539
 540 SilcBool silc_stack_purge(SilcStack stack)
 541 {
 542   SilcStackDataEntry e;
 543   SilcBool ret = FALSE;
 544   int i;
 545
 546   SILC_LOG_DEBUG(("Purge stack %p", stack));
 547
 548   /* Go through the default stack */
 549   for (i = SILC_STACK_BLOCK_NUM - 1; i > 3; i--) {
 550     if (stack->stack->data[i] &&
 551         stack->stack->data[i]->bytes_left == SILC_STACK_BLOCK_SIZE(stack, i)) {
 552       SILC_LOG_DEBUG(("Purge %d bytes",
 553                       SILC_STACK_BLOCK_SIZE(stack, i)));
 554       silc_free(stack->stack->data[i]);
 555       stack->stack->data[i] = NULL;
 556       ret = TRUE;
 557     }
 558   }
 559
 560   silc_mutex_lock(stack->lock);
 561
 562   /* Remove one child stack */
 563   if (silc_list_count(stack->stacks) > 2) {
 564     silc_list_start(stack->stacks);
 565     e = silc_list_get(stack->stacks);
 566
 567     SILC_LOG_DEBUG(("Remove stack blocks %p", e->data));
 568     silc_list_del(stack->stacks, e);
 569     ret = TRUE;
 570
 571     for (i = 0; i < SILC_STACK_BLOCK_NUM; i++)
 572       silc_free(e->data[i]);
 573     silc_free(e);
 574   }
 575
 576   /* Go through the child stacks */
 577   silc_list_start(stack->stacks);
 578   while ((e = silc_list_get(stack->stacks))) {
 579     for (i = SILC_STACK_BLOCK_NUM - 1; i > 3; i--) {
 580       if (e->data[i]) {
 581         SILC_LOG_DEBUG(("Purge %d bytes",
 582                         SILC_STACK_BLOCK_SIZE(stack, i)));
 583         silc_free(e->data[i]);
 584         e->data[i] = NULL;
 585         ret = TRUE;
 586       }
 587     }
 588   }
 589
 590   silc_mutex_unlock(stack->lock);
 591
 592   return ret;
 593 }
 594
 595 #ifdef SILC_DIST_INPLACE
 596 /* Statistics dumping. */
 597
 598 void silc_stack_stats(SilcStack stack)
 599 {
 600   SilcStackDataEntry e;
 601   SilcUInt32 stack_size = 0;
 602   int i, c = 0;
 603
 604   for (i = 0; i < SILC_STACK_BLOCK_NUM; i++) {
 605     if (!stack->stack->data[i])
 606       continue;
 607     stack_size += SILC_STACK_BLOCK_SIZE(stack, i);
 608     c++;
 609   }
 610
 611   fprintf(stdout, "\nSilcStack %p statistics :\n\n", stack);
 612   fprintf(stdout, "  Size of stack           : %u\n",
 613           (unsigned int)stack_size);
 614   fprintf(stdout, "  Stack alignment         : %d\n",
 615           (int)stack->alignment);
 616   fprintf(stdout, "  Number of allocs        : %u\n",
 617           (unsigned int)stack->snum_malloc);
 618   fprintf(stdout, "  Bytes allocated         : %u\n",
 619           (unsigned int)stack->sbytes_malloc);
 620   fprintf(stdout, "  Average alloc size      : %.2f\n",
 621           (double)((double)stack->sbytes_malloc / (double)stack->snum_malloc));
 622   fprintf(stdout, "  Number of alloc errors  : %u\n",
 623           (unsigned int)stack->snum_errors);
 624   fprintf(stdout, "  Number of frames        : %u\n",
 625           (unsigned int)SILC_STACK_ALIGN(stack->frame->sp,
 626                                          SILC_STACK_DEFAULT_NUM));
 627   fprintf(stdout, "  Number of blocks        : %u\n", c);
 628   fprintf(stdout, "  Number of stacks        : %d\n",
 629           silc_list_count(stack->stacks));
 630
 631   silc_list_start(stack->stacks);
 632   while ((e = silc_list_get(stack->stacks))) {
 633     stack_size = 0;
 634     c = 0;
 635     for (i = 0; i < SILC_STACK_BLOCK_NUM; i++) {
 636       if (!e->data[i])
 637         continue;
 638       stack_size += e->data[i]->bytes_left;
 639       c++;
 640     }
 641     fprintf(stdout, "\n  Size of stack           : %u\n",
 642             (unsigned int)stack_size);
 643     fprintf(stdout, "  Number of blocks        : %u\n", c);
 644   }
 645 }
 646 #endif /* SILC_DIST_INPLACE */