Indentation gg=G
authorNikhil Jain <nikhil@illinois.edu>
Thu, 6 Oct 2011 06:03:36 +0000 (01:03 -0500)
committerNikhil Jain <nikhil@illinois.edu>
Thu, 6 Oct 2011 06:03:36 +0000 (01:03 -0500)
src/conv-core/isomalloc.c

index 045cab54499852e48ab1dbf635b3a5c6503ab3ac..c431fcb308bee4dc0f5c6bc6d6f954066abc6ae5 100644 (file)
@@ -7,19 +7,19 @@
 
 /**************************************************************************
 Isomalloc:
 
 /**************************************************************************
 Isomalloc:
-  A way to allocate memory at the same address on every processor.
+A way to allocate memory at the same address on every processor.
 This enables linked data structures, like thread stacks, to be migrated
 to the same address range on other processors.  This is similar to an
 explicitly managed shared memory system.
 
 This enables linked data structures, like thread stacks, to be migrated
 to the same address range on other processors.  This is similar to an
 explicitly managed shared memory system.
 
-  The memory is used and released via the mmap()/mumap() calls, so unused
+The memory is used and released via the mmap()/mumap() calls, so unused
 memory does not take any (RAM, swap or disk) space.
 
 memory does not take any (RAM, swap or disk) space.
 
-  The way it's implemented is that each processor claims some section 
+The way it's implemented is that each processor claims some section 
 of the available virtual address space, and satisfies all new allocations
 from that space.  Migrating structures use whatever space they started with.
 
 of the available virtual address space, and satisfies all new allocations
 from that space.  Migrating structures use whatever space they started with.
 
-  The b-tree implementation has two data structures that are maintained
+The b-tree implementation has two data structures that are maintained
 simultaneously and in conjunction with each other: a b-tree of nodes
 containing slotblocks used for quickly finding a particular slotblock;
 and an array of doubly-linked lists containing the same slotblocks,
 simultaneously and in conjunction with each other: a b-tree of nodes
 containing slotblocks used for quickly finding a particular slotblock;
 and an array of doubly-linked lists containing the same slotblocks,
@@ -29,7 +29,7 @@ The slotset contains pointers to both structures.
 print_btree_top_down() and print_list_array() are very useful
 functions for viewing the current structure of the tree and lists.
 
 print_btree_top_down() and print_list_array() are very useful
 functions for viewing the current structure of the tree and lists.
 
-  Each doubly-linked list has slotblocks containing between 2^(n-1)+1
+Each doubly-linked list has slotblocks containing between 2^(n-1)+1
 and 2^n free slots, where n is the array index (i.e., bin number).
 For example, list_array[0] points to a double-linked list of
 slotblocks with 1 free slot, list_array[1] points to a double-linked
 and 2^n free slots, where n is the array index (i.e., bin number).
 For example, list_array[0] points to a double-linked list of
 slotblocks with 1 free slot, list_array[1] points to a double-linked
@@ -39,7 +39,7 @@ list of slotblocks with 2 free slots, list_array[2] to slotblocks with
 Written for migratable threads by Milind Bhandarkar around August 2000;
 generalized by Orion Lawlor November 2001.  B-tree implementation
 added by Ryan Mokos in July 2008.
 Written for migratable threads by Milind Bhandarkar around August 2000;
 generalized by Orion Lawlor November 2001.  B-tree implementation
 added by Ryan Mokos in July 2008.
-*************************************************************************/
+ *************************************************************************/
 
 #include "converse.h"
 #include "memory-isomalloc.h"
 
 #include "converse.h"
 #include "memory-isomalloc.h"
@@ -47,12 +47,11 @@ added by Ryan Mokos in July 2008.
 #define CMK_THREADS_DEBUG 0
 
 /* 0: use the old non-mempool implementation
 #define CMK_THREADS_DEBUG 0
 
 /* 0: use the old non-mempool implementation
-   1: use the new mempool implementation  */
+1: use the new mempool implementation  */
 #define USE_MEMPOOL_ISOMALLOC 1
 
 #define USE_MEMPOOL_ISOMALLOC 1
 
-
 /* 0: use the old isomalloc implementation (array)
 /* 0: use the old isomalloc implementation (array)
-   1: use the new isomalloc implementation (b-tree)  */
+1: use the new isomalloc implementation (b-tree)  */
 #define USE_BTREE_ISOMALLOC 1
 
 /* b-tree definitions */
 #define USE_BTREE_ISOMALLOC 1
 
 /* b-tree definitions */
@@ -72,6 +71,10 @@ added by Ryan Mokos in July 2008.
 #include <sys/personality.h>
 #endif
 
 #include <sys/personality.h>
 #endif
 
+#if USE_MEMPOOL_ISOMALLOC
+#include "mempool.h"
+#endif 
+
 static int _sync_iso = 0;
 static int _mmap_probe = 0;
 
 static int _sync_iso = 0;
 static int _mmap_probe = 0;
 
@@ -86,9 +89,9 @@ static int read_randomflag(void)
 #if CMK_HAS_ADDR_NO_RANDOMIZE
     if(random_flag)
     {
 #if CMK_HAS_ADDR_NO_RANDOMIZE
     if(random_flag)
     {
-       int persona = personality(0xffffffff);
-       if(persona & ADDR_NO_RANDOMIZE)
-           random_flag = 0;
+      int persona = personality(0xffffffff);
+      if(persona & ADDR_NO_RANDOMIZE)
+        random_flag = 0;
     }
 #endif
   }
     }
 #endif
   }
@@ -99,17 +102,17 @@ static int read_randomflag(void)
 }
 
 struct CmiIsomallocBlock {
 }
 
 struct CmiIsomallocBlock {
-      CmiInt8 slot;   /* First mapped slot */
-      CmiInt8 length; /* Length of (user portion of) mapping, in bytes*/
+  CmiInt8 slot;   /* First mapped slot */
+  CmiInt8 length; /* Length of (user portion of) mapping, in bytes*/
 };
 typedef struct CmiIsomallocBlock CmiIsomallocBlock;
 
 /* Convert a heap block pointer to/from a CmiIsomallocBlock header */
 static void *block2pointer(CmiIsomallocBlock *blockHeader) {
 };
 typedef struct CmiIsomallocBlock CmiIsomallocBlock;
 
 /* Convert a heap block pointer to/from a CmiIsomallocBlock header */
 static void *block2pointer(CmiIsomallocBlock *blockHeader) {
-       return (void *)(blockHeader+1);
+  return (void *)(blockHeader+1);
 }
 static CmiIsomallocBlock *pointer2block(void *heapBlock) {
 }
 static CmiIsomallocBlock *pointer2block(void *heapBlock) {
-       return ((CmiIsomallocBlock *)heapBlock)-1;
+  return ((CmiIsomallocBlock *)heapBlock)-1;
 }
 
 /* Integral type to be used for pointer arithmetic: */
 }
 
 /* Integral type to be used for pointer arithmetic: */
@@ -124,23 +127,23 @@ static CmiInt8 numslots=0;
 
 /* Start and end of isomalloc-managed addresses.
    If isomallocStart==NULL, isomalloc is disabled.
 
 /* Start and end of isomalloc-managed addresses.
    If isomallocStart==NULL, isomalloc is disabled.
-*/
+   */
 static char *isomallocStart=NULL;
 static char *isomallocEnd=NULL;
 
 /* Utility conversion functions */
 static void *slot2addr(CmiInt8 slot) {
 static char *isomallocStart=NULL;
 static char *isomallocEnd=NULL;
 
 /* Utility conversion functions */
 static void *slot2addr(CmiInt8 slot) {
-       return isomallocStart+((memRange_t)slotsize)*((memRange_t)slot);
+  return isomallocStart+((memRange_t)slotsize)*((memRange_t)slot);
 }
 static int slot2pe(CmiInt8 slot) {
 }
 static int slot2pe(CmiInt8 slot) {
-       return (int)(slot/numslots);
+  return (int)(slot/numslots);
 }
 static CmiInt8 pe2slot(int pe) {
 }
 static CmiInt8 pe2slot(int pe) {
-       return pe*numslots;
+  return pe*numslots;
 }
 /* Return the number of slots in a block with n user data bytes */
 static int length2slots(int nBytes) {
 }
 /* Return the number of slots in a block with n user data bytes */
 static int length2slots(int nBytes) {
-       return (sizeof(CmiIsomallocBlock)+nBytes+slotsize-1)/slotsize;
+  return (sizeof(CmiIsomallocBlock)+nBytes+slotsize-1)/slotsize;
 }
 
 /* ======================================================================
 }
 
 /* ======================================================================
@@ -206,14 +209,14 @@ static int find_list_bin(CmiInt8 nslots) {
       list_bin -= inc;
       comp_num  = comp_num >> inc;
       if ((inc = inc >> 1) == 0) {
       list_bin -= inc;
       comp_num  = comp_num >> inc;
       if ((inc = inc >> 1) == 0) {
-       inc = 1;
+        inc = 1;
       }
     } else {
       /* look right */
       list_bin += inc;
       comp_num  = comp_num << inc;
       if ((inc = inc >> 1) == 0) {
       }
     } else {
       /* look right */
       list_bin += inc;
       comp_num  = comp_num << inc;
       if ((inc = inc >> 1) == 0) {
-       inc = 1;
+        inc = 1;
       }
     }
   }
       }
     }
   }
@@ -291,12 +294,12 @@ static void list_move(slotset *ss, dllnode *dlln, CmiInt8 old_nslots) {
     /* remove from old bin */
     if (dlln->previous == NULL) {  /* dlln is the 1st element in the list */
       if (dlln->next != NULL) {
     /* remove from old bin */
     if (dlln->previous == NULL) {  /* dlln is the 1st element in the list */
       if (dlln->next != NULL) {
-       dlln->next->previous = NULL;
+        dlln->next->previous = NULL;
       }
       ss->list_array[old_bin] = dlln->next;
     } else {
       if (dlln->next != NULL) {
       }
       ss->list_array[old_bin] = dlln->next;
     } else {
       if (dlln->next != NULL) {
-       dlln->next->previous = dlln->previous;
+        dlln->next->previous = dlln->previous;
       }
       dlln->previous->next = dlln->next;
     }
       }
       dlln->previous->next = dlln->next;
     }
@@ -353,66 +356,66 @@ static slotblock *find_btree_slotblock(btreenode *node, CmiInt8 startslot) {
       /* if startslot is in current slotblock, this is the slotblock */
       endslot = node->blocks[index].startslot + node->blocks[index].nslots - 1;
       if ((startslot >= node->blocks[index].startslot) &&
       /* if startslot is in current slotblock, this is the slotblock */
       endslot = node->blocks[index].startslot + node->blocks[index].nslots - 1;
       if ((startslot >= node->blocks[index].startslot) &&
-         (startslot <= endslot)) {
-       return &(node->blocks[index]);
+          (startslot <= endslot)) {
+        return &(node->blocks[index]);
       }
 
       /* else, if startslot is less */
       else if (startslot < node->blocks[index].startslot) {
 
       }
 
       /* else, if startslot is less */
       else if (startslot < node->blocks[index].startslot) {
 
-       /* if this is slotblock 0, take the left child */
-       if (index == 0) {
-         return find_btree_slotblock(node->child[index], startslot);
-       }
-
-       /* else check endslot of the slotblock to the left */
-       else {
-
-         /* if startslot > endslot-of-slotblock-to-the-left, take the
-            left child */
-         endslot = node->blocks[index-1].startslot + 
-           node->blocks[index-1].nslots - 1;
-         if (startslot > endslot) {
-           return find_btree_slotblock(node->child[index], startslot);
-         }
-
-         /* else continue to search this node to the left */
-         else {
-           index -= inc;
-           if ((inc = inc >> 1) == 0) {
-             inc = 1;
-           }
-         }
-       }
+        /* if this is slotblock 0, take the left child */
+        if (index == 0) {
+          return find_btree_slotblock(node->child[index], startslot);
+        }
+
+        /* else check endslot of the slotblock to the left */
+        else {
+
+          /* if startslot > endslot-of-slotblock-to-the-left, take the
+             left child */
+          endslot = node->blocks[index-1].startslot + 
+            node->blocks[index-1].nslots - 1;
+          if (startslot > endslot) {
+            return find_btree_slotblock(node->child[index], startslot);
+          }
+
+          /* else continue to search this node to the left */
+          else {
+            index -= inc;
+            if ((inc = inc >> 1) == 0) {
+              inc = 1;
+            }
+          }
+        }
       }
 
       /* else, startslot must be greater */
       else {
 
       }
 
       /* else, startslot must be greater */
       else {
 
-       /* if this is the last slotblock, take the right child */
-       if (index == node->num_blocks - 1) {
-         return find_btree_slotblock(node->child[index+1], startslot);
-       }
-
-       /* else check startslot of the slotblock to the right */
-       else {
-
-         /* if startslot < startslot-of-slotblock-to-the-right, then
-            take the right child */
-         if (startslot < node->blocks[index+1].startslot) {
-           return find_btree_slotblock(node->child[index+1], startslot);
-         }
-
-         /* else continue to search this node to the right */
-         else {
-           index += inc;
-           if ((inc = inc >> 1) == 0) {
-             inc = 1;
-           }
-         }
-       }
+        /* if this is the last slotblock, take the right child */
+        if (index == node->num_blocks - 1) {
+          return find_btree_slotblock(node->child[index+1], startslot);
+        }
+
+        /* else check startslot of the slotblock to the right */
+        else {
+
+          /* if startslot < startslot-of-slotblock-to-the-right, then
+             take the right child */
+          if (startslot < node->blocks[index+1].startslot) {
+            return find_btree_slotblock(node->child[index+1], startslot);
+          }
+
+          /* else continue to search this node to the right */
+          else {
+            index += inc;
+            if ((inc = inc >> 1) == 0) {
+              inc = 1;
+            }
+          }
+        }
       }
       }
-      
+
     }
 
   }
     }
 
   }
@@ -425,7 +428,7 @@ static slotblock *find_btree_slotblock(btreenode *node, CmiInt8 startslot) {
  *****************************************************************/
 
 static insert_ret_val btree_insert_int(slotset *ss, btreenode *node, 
  *****************************************************************/
 
 static insert_ret_val btree_insert_int(slotset *ss, btreenode *node, 
-                                      CmiInt8 startslot, CmiInt8 nslots) {
+    CmiInt8 startslot, CmiInt8 nslots) {
 
   insert_ret_val irv;
 
 
   insert_ret_val irv;
 
@@ -439,179 +442,179 @@ static insert_ret_val btree_insert_int(slotset *ss, btreenode *node,
   while (1) {
     if (startslot < node->blocks[index].startslot) {  /* look to the left */
       if ((index == 0) || 
   while (1) {
     if (startslot < node->blocks[index].startslot) {  /* look to the left */
       if ((index == 0) || 
-         (startslot > node->blocks[index-1].startslot)) {
-       if (node->child[index] != NULL) {             /* take left child */
-         irv = btree_insert_int(ss, node->child[index], startslot, nslots);
-         if (irv.btn == NULL) {
-           return irv;
-         } else {                                    /* merge return value */
-           int i, j;                                 /*   insert on left   */
-           for (i = node->num_blocks; i > index; i--) {
-             node->blocks[i].startslot     = node->blocks[i-1].startslot;
-             node->blocks[i].nslots        = node->blocks[i-1].nslots;
-             node->blocks[i].listblock     = node->blocks[i-1].listblock;
-             node->blocks[i].listblock->sb = &(node->blocks[i]);
-             node->child[i+1]              = node->child[i];
-           }
-           node->blocks[index].startslot     = irv.sb.startslot;
-           node->blocks[index].nslots        = irv.sb.nslots;
-           node->blocks[index].listblock     = irv.sb.listblock;
-           node->blocks[index].listblock->sb = &(node->blocks[index]);
-           node->child[index+1]              = irv.btn;
-           node->num_blocks++;
-           if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
-             btreenode *new_node = create_btree_node();
-             for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
-               j = i - (TREE_NODE_MID + 1);
-               new_node->blocks[j].startslot     = node->blocks[i].startslot;
-               new_node->blocks[j].nslots        = node->blocks[i].nslots;
-               new_node->blocks[j].listblock     = node->blocks[i].listblock;
-               new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
-             }
-             for (i = TREE_NODE_MID + 1; i <= TREE_NODE_SIZE; i++) {
-               new_node->child[i-(TREE_NODE_MID+1)] = node->child[i];
-             }
-             node->num_blocks     = TREE_NODE_MID;
-             new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
-
-             irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
-             irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
-             irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
-             irv.btn          = new_node;
-             return irv;
-           } else {
-             irv.btn = NULL;
-             return irv;
-           }
-         }
-       } else {                                      /* insert to the left */
-         int i, j;
-         for (i = node->num_blocks; i > index; i--) {
-           node->blocks[i].startslot     = node->blocks[i-1].startslot;
-           node->blocks[i].nslots        = node->blocks[i-1].nslots;
-           node->blocks[i].listblock     = node->blocks[i-1].listblock;
-           node->blocks[i].listblock->sb = &(node->blocks[i]);
-         }
-         node->blocks[index].startslot = startslot;
-         node->blocks[index].nslots    = nslots;
-         node->blocks[index].listblock = list_insert(ss, &(node->blocks[index]));
-         node->num_blocks++;
-         if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
-           btreenode *new_node = create_btree_node();
-           for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
-             j = i - (TREE_NODE_MID + 1);
-             new_node->blocks[j].startslot     = node->blocks[i].startslot;
-             new_node->blocks[j].nslots        = node->blocks[i].nslots;
-             new_node->blocks[j].listblock     = node->blocks[i].listblock;
-             new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
-           }
-           node->num_blocks     = TREE_NODE_MID;
-           new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
-
-           irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
-           irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
-           irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
-           irv.btn          = new_node;
-           return irv;
-         } else {
-           irv.btn = NULL;
-           return irv;
-         }
-       }
+          (startslot > node->blocks[index-1].startslot)) {
+        if (node->child[index] != NULL) {             /* take left child */
+          irv = btree_insert_int(ss, node->child[index], startslot, nslots);
+          if (irv.btn == NULL) {
+            return irv;
+          } else {                                    /* merge return value */
+            int i, j;                                 /*   insert on left   */
+            for (i = node->num_blocks; i > index; i--) {
+              node->blocks[i].startslot     = node->blocks[i-1].startslot;
+              node->blocks[i].nslots        = node->blocks[i-1].nslots;
+              node->blocks[i].listblock     = node->blocks[i-1].listblock;
+              node->blocks[i].listblock->sb = &(node->blocks[i]);
+              node->child[i+1]              = node->child[i];
+            }
+            node->blocks[index].startslot     = irv.sb.startslot;
+            node->blocks[index].nslots        = irv.sb.nslots;
+            node->blocks[index].listblock     = irv.sb.listblock;
+            node->blocks[index].listblock->sb = &(node->blocks[index]);
+            node->child[index+1]              = irv.btn;
+            node->num_blocks++;
+            if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
+              btreenode *new_node = create_btree_node();
+              for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
+                j = i - (TREE_NODE_MID + 1);
+                new_node->blocks[j].startslot     = node->blocks[i].startslot;
+                new_node->blocks[j].nslots        = node->blocks[i].nslots;
+                new_node->blocks[j].listblock     = node->blocks[i].listblock;
+                new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
+              }
+              for (i = TREE_NODE_MID + 1; i <= TREE_NODE_SIZE; i++) {
+                new_node->child[i-(TREE_NODE_MID+1)] = node->child[i];
+              }
+              node->num_blocks     = TREE_NODE_MID;
+              new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
+
+              irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
+              irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
+              irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
+              irv.btn          = new_node;
+              return irv;
+            } else {
+              irv.btn = NULL;
+              return irv;
+            }
+          }
+        } else {                                      /* insert to the left */
+          int i, j;
+          for (i = node->num_blocks; i > index; i--) {
+            node->blocks[i].startslot     = node->blocks[i-1].startslot;
+            node->blocks[i].nslots        = node->blocks[i-1].nslots;
+            node->blocks[i].listblock     = node->blocks[i-1].listblock;
+            node->blocks[i].listblock->sb = &(node->blocks[i]);
+          }
+          node->blocks[index].startslot = startslot;
+          node->blocks[index].nslots    = nslots;
+          node->blocks[index].listblock = list_insert(ss, &(node->blocks[index]));
+          node->num_blocks++;
+          if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
+            btreenode *new_node = create_btree_node();
+            for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
+              j = i - (TREE_NODE_MID + 1);
+              new_node->blocks[j].startslot     = node->blocks[i].startslot;
+              new_node->blocks[j].nslots        = node->blocks[i].nslots;
+              new_node->blocks[j].listblock     = node->blocks[i].listblock;
+              new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
+            }
+            node->num_blocks     = TREE_NODE_MID;
+            new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
+
+            irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
+            irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
+            irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
+            irv.btn          = new_node;
+            return irv;
+          } else {
+            irv.btn = NULL;
+            return irv;
+          }
+        }
       } else {                                        /* search to the left */
       } else {                                        /* search to the left */
-       index -= inc;
-       if ((inc = inc >> 1) == 0) {
-         inc = 1;
-       }
+        index -= inc;
+        if ((inc = inc >> 1) == 0) {
+          inc = 1;
+        }
       }
 
     } else {                                          /* look to the right */
 
       if ((index == node->num_blocks - 1) || 
       }
 
     } else {                                          /* look to the right */
 
       if ((index == node->num_blocks - 1) || 
-         (startslot < node->blocks[index+1].startslot)) {
-       if (node->child[index+1] != NULL) {           /* take right child */
-         irv = btree_insert_int(ss, node->child[index+1], startslot, nslots);
-         if (irv.btn == NULL) {
-           return irv;
-         } else {                                    /* merge return value */
-           int i, j;                                 /*   insert on right  */
-           for (i = node->num_blocks; i > index + 1; i--) {
-             node->blocks[i].startslot     = node->blocks[i-1].startslot;
-             node->blocks[i].nslots        = node->blocks[i-1].nslots;
-             node->blocks[i].listblock     = node->blocks[i-1].listblock;
-             node->blocks[i].listblock->sb = &(node->blocks[i]);
-             node->child[i+1]              = node->child[i];
-           }
-           node->blocks[index+1].startslot     = irv.sb.startslot;
-           node->blocks[index+1].nslots        = irv.sb.nslots;
-           node->blocks[index+1].listblock     = irv.sb.listblock;
-           node->blocks[index+1].listblock->sb = &(node->blocks[index+1]);
-           node->child[index+2]                = irv.btn;
-           node->num_blocks++;
-           if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
-             btreenode *new_node = create_btree_node();
-             for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
-               j = i - (TREE_NODE_MID + 1);
-               new_node->blocks[j].startslot     = node->blocks[i].startslot;
-               new_node->blocks[j].nslots        = node->blocks[i].nslots;
-               new_node->blocks[j].listblock     = node->blocks[i].listblock;
-               new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
-             }
-             for (i = TREE_NODE_MID + 1; i <= TREE_NODE_SIZE; i++) {
-               new_node->child[i-(TREE_NODE_MID+1)] = node->child[i];
-             }
-             node->num_blocks     = TREE_NODE_MID;
-             new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
-
-             irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
-             irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
-             irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
-             irv.btn          = new_node;
-             return irv;
-           } else {
-             irv.btn = NULL;
-             return irv;
-           }
-         }
-       } else {                                      /* insert to the right */
-         int i, j;
-         for (i = node->num_blocks; i > index + 1; i--) {
-           node->blocks[i].startslot     = node->blocks[i-1].startslot;
-           node->blocks[i].nslots        = node->blocks[i-1].nslots;
-           node->blocks[i].listblock     = node->blocks[i-1].listblock;
-           node->blocks[i].listblock->sb = &(node->blocks[i]);
-         }
-         node->blocks[index+1].startslot = startslot;
-         node->blocks[index+1].nslots    = nslots;
-         node->blocks[index+1].listblock = list_insert(ss, &(node->blocks[index+1]));
-         node->num_blocks++;
-         if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
-           btreenode *new_node = create_btree_node();
-           for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
-             j = i - (TREE_NODE_MID + 1);
-             new_node->blocks[j].startslot     = node->blocks[i].startslot;
-             new_node->blocks[j].nslots        = node->blocks[i].nslots;
-             new_node->blocks[j].listblock     = node->blocks[i].listblock;
-             new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
-           }
-           node->num_blocks = TREE_NODE_MID;
-           new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
-
-           irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
-           irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
-           irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
-           irv.btn          = new_node;
-           return irv;
-         } else {
-           irv.btn = NULL;
-           return irv;
-         }
-       }
+          (startslot < node->blocks[index+1].startslot)) {
+        if (node->child[index+1] != NULL) {           /* take right child */
+          irv = btree_insert_int(ss, node->child[index+1], startslot, nslots);
+          if (irv.btn == NULL) {
+            return irv;
+          } else {                                    /* merge return value */
+            int i, j;                                 /*   insert on right  */
+            for (i = node->num_blocks; i > index + 1; i--) {
+              node->blocks[i].startslot     = node->blocks[i-1].startslot;
+              node->blocks[i].nslots        = node->blocks[i-1].nslots;
+              node->blocks[i].listblock     = node->blocks[i-1].listblock;
+              node->blocks[i].listblock->sb = &(node->blocks[i]);
+              node->child[i+1]              = node->child[i];
+            }
+            node->blocks[index+1].startslot     = irv.sb.startslot;
+            node->blocks[index+1].nslots        = irv.sb.nslots;
+            node->blocks[index+1].listblock     = irv.sb.listblock;
+            node->blocks[index+1].listblock->sb = &(node->blocks[index+1]);
+            node->child[index+2]                = irv.btn;
+            node->num_blocks++;
+            if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
+              btreenode *new_node = create_btree_node();
+              for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
+                j = i - (TREE_NODE_MID + 1);
+                new_node->blocks[j].startslot     = node->blocks[i].startslot;
+                new_node->blocks[j].nslots        = node->blocks[i].nslots;
+                new_node->blocks[j].listblock     = node->blocks[i].listblock;
+                new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
+              }
+              for (i = TREE_NODE_MID + 1; i <= TREE_NODE_SIZE; i++) {
+                new_node->child[i-(TREE_NODE_MID+1)] = node->child[i];
+              }
+              node->num_blocks     = TREE_NODE_MID;
+              new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
+
+              irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
+              irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
+              irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
+              irv.btn          = new_node;
+              return irv;
+            } else {
+              irv.btn = NULL;
+              return irv;
+            }
+          }
+        } else {                                      /* insert to the right */
+          int i, j;
+          for (i = node->num_blocks; i > index + 1; i--) {
+            node->blocks[i].startslot     = node->blocks[i-1].startslot;
+            node->blocks[i].nslots        = node->blocks[i-1].nslots;
+            node->blocks[i].listblock     = node->blocks[i-1].listblock;
+            node->blocks[i].listblock->sb = &(node->blocks[i]);
+          }
+          node->blocks[index+1].startslot = startslot;
+          node->blocks[index+1].nslots    = nslots;
+          node->blocks[index+1].listblock = list_insert(ss, &(node->blocks[index+1]));
+          node->num_blocks++;
+          if (node->num_blocks == TREE_NODE_SIZE) {   /* split node */
+            btreenode *new_node = create_btree_node();
+            for (i = TREE_NODE_MID + 1; i < TREE_NODE_SIZE; i++) {
+              j = i - (TREE_NODE_MID + 1);
+              new_node->blocks[j].startslot     = node->blocks[i].startslot;
+              new_node->blocks[j].nslots        = node->blocks[i].nslots;
+              new_node->blocks[j].listblock     = node->blocks[i].listblock;
+              new_node->blocks[j].listblock->sb = &(new_node->blocks[j]);
+            }
+            node->num_blocks = TREE_NODE_MID;
+            new_node->num_blocks = TREE_NODE_SIZE - TREE_NODE_MID - 1;
+
+            irv.sb.startslot = node->blocks[TREE_NODE_MID].startslot;
+            irv.sb.nslots    = node->blocks[TREE_NODE_MID].nslots;
+            irv.sb.listblock = node->blocks[TREE_NODE_MID].listblock;
+            irv.btn          = new_node;
+            return irv;
+          } else {
+            irv.btn = NULL;
+            return irv;
+          }
+        }
       } else {                                        /* search to the right */
       } else {                                        /* search to the right */
-       index += inc;
-       if ((inc = inc >> 1) == 0) {
-         inc = 1;
-       }
+        index += inc;
+        if ((inc = inc >> 1) == 0) {
+          inc = 1;
+        }
       }
     }
   }
       }
     }
   }
@@ -619,7 +622,7 @@ static insert_ret_val btree_insert_int(slotset *ss, btreenode *node,
 }
 
 static btreenode *btree_insert(slotset *ss, btreenode *node, 
 }
 
 static btreenode *btree_insert(slotset *ss, btreenode *node, 
-                              CmiInt8 startslot, CmiInt8 nslots) {
+    CmiInt8 startslot, CmiInt8 nslots) {
 
   /* check the b-tree root: if it's empty, insert the element in the
      first position */
 
   /* check the b-tree root: if it's empty, insert the element in the
      first position */
@@ -659,7 +662,7 @@ static btreenode *btree_insert(slotset *ss, btreenode *node,
  *****************************************************************/
 
 static void btree_delete_int(slotset *ss, btreenode *node, 
  *****************************************************************/
 
 static void btree_delete_int(slotset *ss, btreenode *node, 
-                            CmiInt8 startslot, slotblock *sb) {
+    CmiInt8 startslot, slotblock *sb) {
 
   int i, index, inc;
   int def_child;
 
   int i, index, inc;
   int def_child;
@@ -690,10 +693,10 @@ static void btree_delete_int(slotset *ss, btreenode *node,
 
       /* delete the slotblock */
       for (i = 0; i < (node->num_blocks - 1); i++) {
 
       /* delete the slotblock */
       for (i = 0; i < (node->num_blocks - 1); i++) {
-       node->blocks[i].startslot     = node->blocks[i+1].startslot;
-       node->blocks[i].nslots        = node->blocks[i+1].nslots;
-       node->blocks[i].listblock     = node->blocks[i+1].listblock;
-       node->blocks[i].listblock->sb = &(node->blocks[i]);
+        node->blocks[i].startslot     = node->blocks[i+1].startslot;
+        node->blocks[i].nslots        = node->blocks[i+1].nslots;
+        node->blocks[i].listblock     = node->blocks[i+1].listblock;
+        node->blocks[i].listblock->sb = &(node->blocks[i]);
       }
       node->num_blocks--;
 
       }
       node->num_blocks--;
 
@@ -713,46 +716,46 @@ static void btree_delete_int(slotset *ss, btreenode *node,
     while (1) {
 
       if (startslot == node->blocks[index].startslot) {   /* found it */
     while (1) {
 
       if (startslot == node->blocks[index].startslot) {   /* found it */
-       if (node->child[index+1] != NULL) {               /* not a leaf */
-         btree_delete_int(ss, node->child[index+1], 
-                          startslot, &(node->blocks[index]));
-         break;
-       } else {                                          /* is a leaf */
-         /* delete the slotblock */
-         list_delete(ss, &(node->blocks[index]));
-         for (i = index; i < (node->num_blocks - 1); i++) {
-           node->blocks[i].startslot     = node->blocks[i+1].startslot;
-           node->blocks[i].nslots        = node->blocks[i+1].nslots;
-           node->blocks[i].listblock     = node->blocks[i+1].listblock;
-           node->blocks[i].listblock->sb = &(node->blocks[i]);
-         }
-         node->num_blocks--;
-         return;
-       }
+        if (node->child[index+1] != NULL) {               /* not a leaf */
+          btree_delete_int(ss, node->child[index+1], 
+              startslot, &(node->blocks[index]));
+          break;
+        } else {                                          /* is a leaf */
+          /* delete the slotblock */
+          list_delete(ss, &(node->blocks[index]));
+          for (i = index; i < (node->num_blocks - 1); i++) {
+            node->blocks[i].startslot     = node->blocks[i+1].startslot;
+            node->blocks[i].nslots        = node->blocks[i+1].nslots;
+            node->blocks[i].listblock     = node->blocks[i+1].listblock;
+            node->blocks[i].listblock->sb = &(node->blocks[i]);
+          }
+          node->num_blocks--;
+          return;
+        }
       } else {
       } else {
-       if (startslot < node->blocks[index].startslot) {  /* look left */
-         if ((index == 0) ||                             /* take left child */
-             (startslot > node->blocks[index-1].startslot)) {
-           btree_delete_int(ss, node->child[index], startslot, sb);
-           break;
-         } else {                                        /* search left */
-           index -= inc;
-           if ((inc = inc >> 1) == 0) {
-             inc = 1;
-           }
-         }
-       } else {                                          /* look right */
-         if ((index == node->num_blocks - 1) ||          /* take right child */
-             (startslot < node->blocks[index+1].startslot)) {
-           btree_delete_int(ss, node->child[index+1], startslot, sb);
-           break;
-         } else {                                        /* search right */
-           index += inc;
-           if ((inc = inc >> 1) == 0) {
-             inc = 1;
-           }
-         }
-       }
+        if (startslot < node->blocks[index].startslot) {  /* look left */
+          if ((index == 0) ||                             /* take left child */
+              (startslot > node->blocks[index-1].startslot)) {
+            btree_delete_int(ss, node->child[index], startslot, sb);
+            break;
+          } else {                                        /* search left */
+            index -= inc;
+            if ((inc = inc >> 1) == 0) {
+              inc = 1;
+            }
+          }
+        } else {                                          /* look right */
+          if ((index == node->num_blocks - 1) ||          /* take right child */
+              (startslot < node->blocks[index+1].startslot)) {
+            btree_delete_int(ss, node->child[index+1], startslot, sb);
+            break;
+          } else {                                        /* search right */
+            index += inc;
+            if ((inc = inc >> 1) == 0) {
+              inc = 1;
+            }
+          }
+        }
       }
 
     }
       }
 
     }
@@ -777,51 +780,51 @@ static void btree_delete_int(slotset *ss, btreenode *node,
     /* if there is a left sibling and it has enough elements, rotate */
     /* to the right */
     if ((def_child != 0) && (node->child[def_child-1] != NULL) && 
     /* if there is a left sibling and it has enough elements, rotate */
     /* to the right */
     if ((def_child != 0) && (node->child[def_child-1] != NULL) && 
-       (node->child[def_child-1]->num_blocks > TREE_NODE_MID)) {
+        (node->child[def_child-1]->num_blocks > TREE_NODE_MID)) {
 
       /* move all elements in deficient child to the right */
       for (i = node->child[def_child]->num_blocks; i > 0; i--) {
 
       /* move all elements in deficient child to the right */
       for (i = node->child[def_child]->num_blocks; i > 0; i--) {
-       node->child[def_child]->blocks[i].startslot = 
-         node->child[def_child]->blocks[i-1].startslot;
-       node->child[def_child]->blocks[i].nslots = 
-         node->child[def_child]->blocks[i-1].nslots;
-       node->child[def_child]->blocks[i].listblock = 
-         node->child[def_child]->blocks[i-1].listblock;
-       node->child[def_child]->blocks[i].listblock->sb = 
-         &(node->child[def_child]->blocks[i]);
+        node->child[def_child]->blocks[i].startslot = 
+          node->child[def_child]->blocks[i-1].startslot;
+        node->child[def_child]->blocks[i].nslots = 
+          node->child[def_child]->blocks[i-1].nslots;
+        node->child[def_child]->blocks[i].listblock = 
+          node->child[def_child]->blocks[i-1].listblock;
+        node->child[def_child]->blocks[i].listblock->sb = 
+          &(node->child[def_child]->blocks[i]);
       }
       for (i = node->child[def_child]->num_blocks + 1; i > 0; i--) {
       }
       for (i = node->child[def_child]->num_blocks + 1; i > 0; i--) {
-       node->child[def_child]->child[i] = 
-         node->child[def_child]->child[i-1];
+        node->child[def_child]->child[i] = 
+          node->child[def_child]->child[i-1];
       }
 
       /* move parent element to the deficient child */
       node->child[def_child]->blocks[0].startslot = 
       }
 
       /* move parent element to the deficient child */
       node->child[def_child]->blocks[0].startslot = 
-       node->blocks[def_child-1].startslot;
+        node->blocks[def_child-1].startslot;
       node->child[def_child]->blocks[0].nslots = 
       node->child[def_child]->blocks[0].nslots = 
-       node->blocks[def_child-1].nslots;
+        node->blocks[def_child-1].nslots;
       node->child[def_child]->blocks[0].listblock = 
       node->child[def_child]->blocks[0].listblock = 
-       node->blocks[def_child-1].listblock;
+        node->blocks[def_child-1].listblock;
       node->child[def_child]->blocks[0].listblock->sb = 
       node->child[def_child]->blocks[0].listblock->sb = 
-       &(node->child[def_child]->blocks[0]);
+        &(node->child[def_child]->blocks[0]);
       node->child[def_child]->num_blocks++;
 
       /* move the right-most child of the parent's left child to the
          left-most child of the formerly deficient child  */
       i = node->child[def_child-1]->num_blocks;
       node->child[def_child]->child[0] = 
       node->child[def_child]->num_blocks++;
 
       /* move the right-most child of the parent's left child to the
          left-most child of the formerly deficient child  */
       i = node->child[def_child-1]->num_blocks;
       node->child[def_child]->child[0] = 
-       node->child[def_child-1]->child[i];
+        node->child[def_child-1]->child[i];
 
       /* move largest element from left child up to the parent */
       i--;
       node->blocks[def_child-1].startslot = 
 
       /* move largest element from left child up to the parent */
       i--;
       node->blocks[def_child-1].startslot = 
-       node->child[def_child-1]->blocks[i].startslot;
+        node->child[def_child-1]->blocks[i].startslot;
       node->blocks[def_child-1].nslots = 
       node->blocks[def_child-1].nslots = 
-       node->child[def_child-1]->blocks[i].nslots;
+        node->child[def_child-1]->blocks[i].nslots;
       node->blocks[def_child-1].listblock = 
       node->blocks[def_child-1].listblock = 
-       node->child[def_child-1]->blocks[i].listblock;
+        node->child[def_child-1]->blocks[i].listblock;
       node->blocks[def_child-1].listblock->sb = 
       node->blocks[def_child-1].listblock->sb = 
-       &(node->blocks[def_child-1]);
+        &(node->blocks[def_child-1]);
       node->child[def_child-1]->num_blocks--;
 
     }
       node->child[def_child-1]->num_blocks--;
 
     }
@@ -829,52 +832,52 @@ static void btree_delete_int(slotset *ss, btreenode *node,
     /* otherwise, if there is a right sibling and it has enough */
     /* elements, rotate to the left */
     else if (((def_child + 1) <= node->num_blocks) && 
     /* otherwise, if there is a right sibling and it has enough */
     /* elements, rotate to the left */
     else if (((def_child + 1) <= node->num_blocks) && 
-            (node->child[def_child+1] != NULL) && 
-            (node->child[def_child+1]->num_blocks > TREE_NODE_MID)) {
+        (node->child[def_child+1] != NULL) && 
+        (node->child[def_child+1]->num_blocks > TREE_NODE_MID)) {
 
       /* move parent element to the deficient child */
       i = node->child[def_child]->num_blocks;
       node->child[def_child]->blocks[i].startslot = 
 
       /* move parent element to the deficient child */
       i = node->child[def_child]->num_blocks;
       node->child[def_child]->blocks[i].startslot = 
-       node->blocks[def_child].startslot;
+        node->blocks[def_child].startslot;
       node->child[def_child]->blocks[i].nslots = 
       node->child[def_child]->blocks[i].nslots = 
-       node->blocks[def_child].nslots;
+        node->blocks[def_child].nslots;
       node->child[def_child]->blocks[i].listblock = 
       node->child[def_child]->blocks[i].listblock = 
-       node->blocks[def_child].listblock;
+        node->blocks[def_child].listblock;
       node->child[def_child]->blocks[i].listblock->sb = 
       node->child[def_child]->blocks[i].listblock->sb = 
-       &(node->child[def_child]->blocks[i]);
+        &(node->child[def_child]->blocks[i]);
       node->child[def_child]->num_blocks++;
 
       /* move the left-most child of the parent's right child to the
          right-most child of the formerly deficient child  */
       i++;
       node->child[def_child]->child[i] = 
       node->child[def_child]->num_blocks++;
 
       /* move the left-most child of the parent's right child to the
          right-most child of the formerly deficient child  */
       i++;
       node->child[def_child]->child[i] = 
-       node->child[def_child+1]->child[0];
+        node->child[def_child+1]->child[0];
 
       /* move smallest element from right child up to the parent */
       node->blocks[def_child].startslot = 
 
       /* move smallest element from right child up to the parent */
       node->blocks[def_child].startslot = 
-       node->child[def_child+1]->blocks[0].startslot;
+        node->child[def_child+1]->blocks[0].startslot;
       node->blocks[def_child].nslots = 
       node->blocks[def_child].nslots = 
-       node->child[def_child+1]->blocks[0].nslots;
+        node->child[def_child+1]->blocks[0].nslots;
       node->blocks[def_child].listblock = 
       node->blocks[def_child].listblock = 
-       node->child[def_child+1]->blocks[0].listblock;
+        node->child[def_child+1]->blocks[0].listblock;
       node->blocks[def_child].listblock->sb = 
       node->blocks[def_child].listblock->sb = 
-       &(node->blocks[def_child]);
+        &(node->blocks[def_child]);
       node->child[def_child+1]->num_blocks--;
 
       /* move all elements in the parent's right child to the left  */
       for (i = 0; i < node->child[def_child+1]->num_blocks; i++) {
       node->child[def_child+1]->num_blocks--;
 
       /* move all elements in the parent's right child to the left  */
       for (i = 0; i < node->child[def_child+1]->num_blocks; i++) {
-       node->child[def_child+1]->blocks[i].startslot = 
-         node->child[def_child+1]->blocks[i+1].startslot;
-       node->child[def_child+1]->blocks[i].nslots = 
-         node->child[def_child+1]->blocks[i+1].nslots;
-       node->child[def_child+1]->blocks[i].listblock = 
-         node->child[def_child+1]->blocks[i+1].listblock;
-       node->child[def_child+1]->blocks[i].listblock->sb = 
-         &(node->child[def_child+1]->blocks[i]);
+        node->child[def_child+1]->blocks[i].startslot = 
+          node->child[def_child+1]->blocks[i+1].startslot;
+        node->child[def_child+1]->blocks[i].nslots = 
+          node->child[def_child+1]->blocks[i+1].nslots;
+        node->child[def_child+1]->blocks[i].listblock = 
+          node->child[def_child+1]->blocks[i+1].listblock;
+        node->child[def_child+1]->blocks[i].listblock->sb = 
+          &(node->child[def_child+1]->blocks[i]);
       }
       for (i = 0; i < node->child[def_child+1]->num_blocks + 1; i++) {
       }
       for (i = 0; i < node->child[def_child+1]->num_blocks + 1; i++) {
-       node->child[def_child+1]->child[i] = 
-         node->child[def_child+1]->child[i+1];
+        node->child[def_child+1]->child[i] = 
+          node->child[def_child+1]->child[i+1];
       }
     }
 
       }
     }
 
@@ -886,13 +889,13 @@ static void btree_delete_int(slotset *ss, btreenode *node,
       /* move the parent element into the left child node */
       i = node->child[index]->num_blocks;
       node->child[index]->blocks[i].startslot = 
       /* move the parent element into the left child node */
       i = node->child[index]->num_blocks;
       node->child[index]->blocks[i].startslot = 
-       node->blocks[index].startslot;
+        node->blocks[index].startslot;
       node->child[index]->blocks[i].nslots = 
       node->child[index]->blocks[i].nslots = 
-       node->blocks[index].nslots;
+        node->blocks[index].nslots;
       node->child[index]->blocks[i].listblock = 
       node->child[index]->blocks[i].listblock = 
-       node->blocks[index].listblock;
+        node->blocks[index].listblock;
       node->child[index]->blocks[i].listblock->sb = 
       node->child[index]->blocks[i].listblock->sb = 
-       &(node->child[index]->blocks[i]);
+        &(node->child[index]->blocks[i]);
       node->child[index]->num_blocks++;
 
       /* move the elements and children of the right child node to the */
       node->child[index]->num_blocks++;
 
       /* move the elements and children of the right child node to the */
@@ -902,21 +905,21 @@ static void btree_delete_int(slotset *ss, btreenode *node,
       left_pos;
       right_pos = 0;
       for (left_pos = num_left; left_pos < num_left + num_right; left_pos++) {
       left_pos;
       right_pos = 0;
       for (left_pos = num_left; left_pos < num_left + num_right; left_pos++) {
-       node->child[index]->blocks[left_pos].startslot = 
-         node->child[index+1]->blocks[right_pos].startslot;
-       node->child[index]->blocks[left_pos].nslots = 
-         node->child[index+1]->blocks[right_pos].nslots;
-       node->child[index]->blocks[left_pos].listblock = 
-         node->child[index+1]->blocks[right_pos].listblock;
-       node->child[index]->blocks[left_pos].listblock->sb = 
-         &(node->child[index]->blocks[left_pos]);
-       right_pos++;
+        node->child[index]->blocks[left_pos].startslot = 
+          node->child[index+1]->blocks[right_pos].startslot;
+        node->child[index]->blocks[left_pos].nslots = 
+          node->child[index+1]->blocks[right_pos].nslots;
+        node->child[index]->blocks[left_pos].listblock = 
+          node->child[index+1]->blocks[right_pos].listblock;
+        node->child[index]->blocks[left_pos].listblock->sb = 
+          &(node->child[index]->blocks[left_pos]);
+        right_pos++;
       }
       right_pos = 0;
       for (left_pos = num_left; left_pos < num_left + num_right + 1; left_pos++) {
       }
       right_pos = 0;
       for (left_pos = num_left; left_pos < num_left + num_right + 1; left_pos++) {
-       node->child[index]->child[left_pos] = 
-         node->child[index+1]->child[right_pos];
-       right_pos++;
+        node->child[index]->child[left_pos] = 
+          node->child[index+1]->child[right_pos];
+        right_pos++;
       }
       node->child[index]->num_blocks = num_left + num_right;
 
       }
       node->child[index]->num_blocks = num_left + num_right;
 
@@ -927,11 +930,11 @@ static void btree_delete_int(slotset *ss, btreenode *node,
       /* update the parent node */
       node->num_blocks--;
       for (i = index; i < node->num_blocks; i++) {
       /* update the parent node */
       node->num_blocks--;
       for (i = index; i < node->num_blocks; i++) {
-       node->blocks[i].startslot     = node->blocks[i+1].startslot;
-       node->blocks[i].nslots        = node->blocks[i+1].nslots;
-       node->blocks[i].listblock     = node->blocks[i+1].listblock;
-       node->blocks[i].listblock->sb = &(node->blocks[i]);
-       node->child[i+1]              = node->child[i+2];
+        node->blocks[i].startslot     = node->blocks[i+1].startslot;
+        node->blocks[i].nslots        = node->blocks[i+1].nslots;
+        node->blocks[i].listblock     = node->blocks[i+1].listblock;
+        node->blocks[i].listblock->sb = &(node->blocks[i]);
+        node->child[i+1]              = node->child[i+2];
       }
 
     }
       }
 
     }
@@ -1017,7 +1020,7 @@ static CmiInt8 get_slots(slotset *ss, CmiInt8 nslots) {
     dlln = ss->list_array[i];
     while (dlln != NULL) {
       if (dlln->sb->nslots >= nslots) {
     dlln = ss->list_array[i];
     while (dlln != NULL) {
       if (dlln->sb->nslots >= nslots) {
-       return dlln->sb->startslot;
+        return dlln->sb->startslot;
       }
       dlln = dlln->next;
     }
       }
       dlln = dlln->next;
     }
@@ -1044,20 +1047,20 @@ static void grab_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots) {
   if (sb == NULL) {
     CmiAbort("requested a non-existent slotblock\n");
   } else {
   if (sb == NULL) {
     CmiAbort("requested a non-existent slotblock\n");
   } else {
-    
+
     if (sb->startslot == sslot) {
 
       /* range is exact range of slotblock - delete block from tree */
       if (sb->nslots == nslots) {
     if (sb->startslot == sslot) {
 
       /* range is exact range of slotblock - delete block from tree */
       if (sb->nslots == nslots) {
-       ss->btree_root = btree_delete(ss, ss->btree_root, sslot);
+        ss->btree_root = btree_delete(ss, ss->btree_root, sslot);
       }
 
       /* range is at beginning of slotblock - update block range */
       else {
       }
 
       /* range is at beginning of slotblock - update block range */
       else {
-       CmiInt8 old_nslots = sb->nslots;
-       sb->startslot     += nslots;
-       sb->nslots        -= nslots;
-       list_move(ss, sb->listblock, old_nslots);
+        CmiInt8 old_nslots = sb->nslots;
+        sb->startslot     += nslots;
+        sb->nslots        -= nslots;
+        list_move(ss, sb->listblock, old_nslots);
       }
 
     } else {
       }
 
     } else {
@@ -1065,19 +1068,19 @@ static void grab_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots) {
       /* range is at end of slotblock - update block range */
       endslot = sb->startslot + sb->nslots - 1;
       if (endslot == (sslot + nslots - 1)) {
       /* range is at end of slotblock - update block range */
       endslot = sb->startslot + sb->nslots - 1;
       if (endslot == (sslot + nslots - 1)) {
-       CmiInt8 old_nslots = sb->nslots;
-       sb->nslots        -= nslots;
-       list_move(ss, sb->listblock, old_nslots);
+        CmiInt8 old_nslots = sb->nslots;
+        sb->nslots        -= nslots;
+        list_move(ss, sb->listblock, old_nslots);
       }
 
       /* range is in middle of slotblock - update block range with the */
       /* new lower range and insert a block with the new upper range */
       else {
       }
 
       /* range is in middle of slotblock - update block range with the */
       /* new lower range and insert a block with the new upper range */
       else {
-       CmiInt8 old_nslots = sb->nslots;
-       sb->nslots         = sslot - sb->startslot;
-       list_move(ss, sb->listblock, old_nslots);
-       ss->btree_root = btree_insert(ss, ss->btree_root, sslot + nslots, 
-                                     endslot - (sslot + nslots) + 1);
+        CmiInt8 old_nslots = sb->nslots;
+        sb->nslots         = sslot - sb->startslot;
+        list_move(ss, sb->listblock, old_nslots);
+        ss->btree_root = btree_insert(ss, ss->btree_root, sslot + nslots, 
+            endslot - (sslot + nslots) + 1);
       }
 
     }
       }
 
     }
@@ -1164,11 +1167,11 @@ static void delete_list_array(slotset *ss) {
     dlln = ss->list_array[i];
     if (dlln != NULL) {
       while (dlln->next != NULL) {
     dlln = ss->list_array[i];
     if (dlln != NULL) {
       while (dlln->next != NULL) {
-       dlln = dlln->next;
+        dlln = dlln->next;
       }
       while (dlln->previous != NULL) {
       }
       while (dlln->previous != NULL) {
-       dlln = dlln->previous;
-       free_reentrant(dlln->next);
+        dlln = dlln->previous;
+        free_reentrant(dlln->next);
       }
       free_reentrant(dlln);
     }
       }
       free_reentrant(dlln);
     }
@@ -1208,13 +1211,13 @@ static int print_btree_level(btreenode *node, int level, int current_level, int
     if (current_level == level) {
       print_btree_node(node, node_num);
       if (node->child[0] == NULL) {
     if (current_level == level) {
       print_btree_node(node, node_num);
       if (node->child[0] == NULL) {
-       return 0;
+        return 0;
       } else {
       } else {
-       return 1;
+        return 1;
       }
     } else {
       another_level = print_btree_level(node->child[i], level, 
       }
     } else {
       another_level = print_btree_level(node->child[i], level, 
-                                       current_level + 1, i);
+          current_level + 1, i);
     }
   }
   return another_level;
     }
   }
   return another_level;
@@ -1246,9 +1249,9 @@ static void print_list_array(slotset *ss) {
     dlln = ss->list_array[i];
     while (dlln != NULL) {
       if (dlln->previous != NULL) {
     dlln = ss->list_array[i];
     while (dlln != NULL) {
       if (dlln->previous != NULL) {
-       CmiPrintf("<->");
+        CmiPrintf("<->");
       } else {
       } else {
-       CmiPrintf(" ->");
+        CmiPrintf(" ->");
       }
       CmiPrintf("[%lld,%lld]", dlln->sb->startslot, dlln->sb->nslots);
       dlln = dlln->next;
       }
       CmiPrintf("[%lld,%lld]", dlln->sb->startslot, dlln->sb->nslots);
       dlln = dlln->next;
@@ -1292,7 +1295,7 @@ typedef struct _slotset
  * empty slots. The slot numbers are [startslot,startslot+nslot-1]
  */
 
  * empty slots. The slot numbers are [startslot,startslot+nslot-1]
  */
 
-static slotset *
+  static slotset *
 new_slotset(CmiInt8 startslot, CmiInt8 nslots)
 {
   /* CmiPrintf("*** Old isomalloc ***\n"); */
 new_slotset(CmiInt8 startslot, CmiInt8 nslots)
 {
   /* CmiPrintf("*** Old isomalloc ***\n"); */
@@ -1314,7 +1317,7 @@ new_slotset(CmiInt8 startslot, CmiInt8 nslots)
  * returns new block of empty slots. if it cannot find any, returns (-1).
  */
 
  * returns new block of empty slots. if it cannot find any, returns (-1).
  */
 
-static CmiInt8
+  static CmiInt8
 get_slots(slotset *ss, CmiInt8 nslots)
 {
   /* CmiPrintf("old get: nslots=%lld\n", nslots); */
 get_slots(slotset *ss, CmiInt8 nslots)
 {
   /* CmiPrintf("old get: nslots=%lld\n", nslots); */
@@ -1329,7 +1332,7 @@ get_slots(slotset *ss, CmiInt8 nslots)
 
 /* just adds a slotblock to an empty position in the given slotset. */
 
 
 /* just adds a slotblock to an empty position in the given slotset. */
 
-static void
+  static void
 add_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 {
   int pos; 
 add_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 {
   int pos; 
@@ -1367,7 +1370,7 @@ add_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
  * this is different from get_slots, since it pre-specifies the
  * slots to be grabbed.
  */
  * this is different from get_slots, since it pre-specifies the
  * slots to be grabbed.
  */
-static void
+  static void
 grab_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 {
   /* CmiPrintf("old grab: sslot=%lld nslots=%lld\n", sslot, nslots); */
 grab_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 {
   /* CmiPrintf("old grab: sslot=%lld nslots=%lld\n", sslot, nslots); */
@@ -1398,7 +1401,7 @@ grab_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
  * if it cannot find such a slotblock, it creates a new slotblock.
  * If the buffer fills up, it adds up extra buffer space.
  */
  * if it cannot find such a slotblock, it creates a new slotblock.
  * If the buffer fills up, it adds up extra buffer space.
  */
-static void
+  static void
 free_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 {
   /* CmiPrintf("old free: sslot=%lld nslots=%lld\n", sslot, nslots); */
 free_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 {
   /* CmiPrintf("old free: sslot=%lld nslots=%lld\n", sslot, nslots); */
@@ -1413,18 +1416,18 @@ free_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
     /* e is the ending slot of pos'th slotblock */
     if (e == sslot) /* append to the current slotblock */
     {
     /* e is the ending slot of pos'th slotblock */
     if (e == sslot) /* append to the current slotblock */
     {
-           ss->buf[pos].nslots += nslots;
-           ss->emptyslots += nslots;
-           /* CmiPrintf("free:append pos=%d\n", pos); */
-           return;
+      ss->buf[pos].nslots += nslots;
+      ss->emptyslots += nslots;
+      /* CmiPrintf("free:append pos=%d\n", pos); */
+      return;
     }
     if(eslot == ss->buf[pos].startslot) /* prepend to the current slotblock */
     {
     }
     if(eslot == ss->buf[pos].startslot) /* prepend to the current slotblock */
     {
-           ss->buf[pos].startslot = sslot;
-           ss->buf[pos].nslots += nslots;
-           ss->emptyslots += nslots;
-           /* CmiPrintf("free:prepend pos=%d\n", pos); */
-           return;
+      ss->buf[pos].startslot = sslot;
+      ss->buf[pos].nslots += nslots;
+      ss->emptyslots += nslots;
+      /* CmiPrintf("free:prepend pos=%d\n", pos); */
+      return;
     }
   }
   /* if we are here, it means we could not find a slotblock that the */
     }
   }
   /* if we are here, it means we could not find a slotblock that the */
@@ -1435,16 +1438,16 @@ free_slots(slotset *ss, CmiInt8 sslot, CmiInt8 nslots)
 
 /*
  * destroys slotset-- currently unused
 
 /*
  * destroys slotset-- currently unused
-static void
-delete_slotset(slotset* ss)
-{
 free_reentrant(ss->buf);
 free_reentrant(ss);
-}
-*/
+ static void
+ delete_slotset(slotset* ss)
+ {
+ free_reentrant(ss->buf);
+ free_reentrant(ss);
+ }
+ */
 
 #if CMK_THREADS_DEBUG
 
 #if CMK_THREADS_DEBUG
-static void
+  static void
 print_slots(slotset *ss)
 {
   int i;
 print_slots(slotset *ss)
 {
   int i;
@@ -1458,7 +1461,7 @@ print_slots(slotset *ss)
 }
 #else
 /*#  define print_slots(ss) */ /*empty*/
 }
 #else
 /*#  define print_slots(ss) */ /*empty*/
-static void
+  static void
 print_slots(slotset *ss)
 {
   int i;
 print_slots(slotset *ss)
 {
   int i;
@@ -1480,46 +1483,46 @@ print_slots(slotset *ss)
 
 
 /*This version of the allocate/deallocate calls are used if the 
 
 
 /*This version of the allocate/deallocate calls are used if the 
-real mmap versions are disabled.*/
+  real mmap versions are disabled.*/
 static int disabled_map_warned=0;
 static void *disabled_map(int nBytes) 
 {
 static int disabled_map_warned=0;
 static void *disabled_map(int nBytes) 
 {
-       if (!disabled_map_warned) {
-               disabled_map_warned=1;
-               if (CmiMyPe()==0)
-                       CmiError("charm isomalloc.c> Warning: since mmap() doesn't work,"
-                       " you won't be able to migrate threads\n");
-       }
-       return malloc(nBytes);
+  if (!disabled_map_warned) {
+    disabled_map_warned=1;
+    if (CmiMyPe()==0)
+      CmiError("charm isomalloc.c> Warning: since mmap() doesn't work,"
+          " you won't be able to migrate threads\n");
+  }
+  return malloc(nBytes);
 }
 static void disabled_unmap(void *bk) {
 }
 static void disabled_unmap(void *bk) {
-       free(bk);
+  free(bk);
 }
 
 /*Turn off isomalloc memory, for the given reason*/
 static void disable_isomalloc(const char *why)
 {
 }
 
 /*Turn off isomalloc memory, for the given reason*/
 static void disable_isomalloc(const char *why)
 {
-    isomallocStart=NULL;
-    isomallocEnd=NULL;
-    if (CmiMyPe() == 0)
+  isomallocStart=NULL;
+  isomallocEnd=NULL;
+  if (CmiMyPe() == 0)
     CmiPrintf("[%d] isomalloc.c> Disabling isomalloc because %s\n",CmiMyPe(),why);
 }
 
 #if ! CMK_HAS_MMAP
 /****************** Manipulate memory map (Win32 non-version) *****************/
 static void *call_mmap_fixed(void *addr,size_t len) {
     CmiPrintf("[%d] isomalloc.c> Disabling isomalloc because %s\n",CmiMyPe(),why);
 }
 
 #if ! CMK_HAS_MMAP
 /****************** Manipulate memory map (Win32 non-version) *****************/
 static void *call_mmap_fixed(void *addr,size_t len) {
-       CmiAbort("isomalloc.c: mmap_fixed should never be called here.");
-       return NULL;
+  CmiAbort("isomalloc.c: mmap_fixed should never be called here.");
+  return NULL;
 }
 static void *call_mmap_anywhere(size_t len) {
 }
 static void *call_mmap_anywhere(size_t len) {
-       CmiAbort("isomalloc.c: mmap_anywhere should never be called here.");
-       return NULL;
+  CmiAbort("isomalloc.c: mmap_anywhere should never be called here.");
+  return NULL;
 }
 static void call_munmap(void *addr,size_t len) {
 }
 static void call_munmap(void *addr,size_t len) {
-       CmiAbort("isomalloc.c: munmap should never be called here.");
+  CmiAbort("isomalloc.c: munmap should never be called here.");
 }
 
 }
 
-static int 
+  static int 
 init_map(char **argv)
 {
   return 0; /*Isomalloc never works without mmap*/
 init_map(char **argv)
 {
   return 0; /*Isomalloc never works without mmap*/
@@ -1541,19 +1544,19 @@ CpvStaticDeclare(int, zerofd); /*File descriptor for /dev/zero, for mmap*/
 static void *call_mmap(void *addr,size_t len, int flags) {
   void *ret=mmap(addr, len, PROT_READ|PROT_WRITE,
 #if CMK_HAS_MMAP_ANON
 static void *call_mmap(void *addr,size_t len, int flags) {
   void *ret=mmap(addr, len, PROT_READ|PROT_WRITE,
 #if CMK_HAS_MMAP_ANON
-           flags|MAP_PRIVATE|MAP_ANON,-1,
+      flags|MAP_PRIVATE|MAP_ANON,-1,
 #else
 #else
-           flags|MAP_PRIVATE,CpvAccess(zerofd),
+      flags|MAP_PRIVATE,CpvAccess(zerofd),
 #endif
 #endif
-           0);
+      0);
   if (ret==((void*)(-1))) return (void *)0; /* all-ones means failure */
   else return ret;
 }
 static void *call_mmap_fixed(void *addr,size_t len) {
   if (ret==((void*)(-1))) return (void *)0; /* all-ones means failure */
   else return ret;
 }
 static void *call_mmap_fixed(void *addr,size_t len) {
-       return call_mmap(addr,len,MAP_FIXED);
+  return call_mmap(addr,len,MAP_FIXED);
 }
 static void *call_mmap_anywhere(size_t len) {
 }
 static void *call_mmap_anywhere(size_t len) {
-       return call_mmap((void *)0,len,0);
+  return call_mmap((void *)0,len,0);
 }
 
 /* Unmaps this address range */
 }
 
 /* Unmaps this address range */
@@ -1565,7 +1568,7 @@ static void call_munmap(void *addr,size_t len) {
     CmiAbort("munmap call failed to deallocate requested memory.\n");
 }
 
     CmiAbort("munmap call failed to deallocate requested memory.\n");
 }
 
-static int 
+  static int 
 init_map(char **argv)
 {
 #if CMK_HAS_MMAP_ANON
 init_map(char **argv)
 {
 #if CMK_HAS_MMAP_ANON
@@ -1584,7 +1587,7 @@ init_map(char **argv)
 /**
  * maps the virtual memory associated with slot using mmap
  */
 /**
  * maps the virtual memory associated with slot using mmap
  */
-static CmiIsomallocBlock *
+  static CmiIsomallocBlock *
 map_slots(CmiInt8 slot, CmiInt8 nslots)
 {
   void *pa;
 map_slots(CmiInt8 slot, CmiInt8 nslots)
 {
   void *pa;
@@ -1609,7 +1612,7 @@ map_slots(CmiInt8 slot, CmiInt8 nslots)
   }
 #if CMK_THREADS_DEBUG
   CmiPrintf("[%d] mmap'd slots %ld-%ld to address %p\n",CmiMyPe(),
   }
 #if CMK_THREADS_DEBUG
   CmiPrintf("[%d] mmap'd slots %ld-%ld to address %p\n",CmiMyPe(),
-            slot,slot+nslots-1,addr);
+      slot,slot+nslots-1,addr);
 #endif
   return (CmiIsomallocBlock *)pa;
 }
 #endif
   return (CmiIsomallocBlock *)pa;
 }
@@ -1617,14 +1620,14 @@ map_slots(CmiInt8 slot, CmiInt8 nslots)
 /*
  * unmaps the virtual memory associated with slot using munmap
  */
 /*
  * unmaps the virtual memory associated with slot using munmap
  */
-static void
+  static void
 unmap_slots(CmiInt8 slot, CmiInt8 nslots)
 {
   void *addr=slot2addr(slot);
   call_munmap(addr, slotsize*nslots);
 #if CMK_THREADS_DEBUG
   CmiPrintf("[%d] munmap'd slots %ld-%ld from address %p\n",CmiMyPe(),
 unmap_slots(CmiInt8 slot, CmiInt8 nslots)
 {
   void *addr=slot2addr(slot);
   call_munmap(addr, slotsize*nslots);
 #if CMK_THREADS_DEBUG
   CmiPrintf("[%d] munmap'd slots %ld-%ld from address %p\n",CmiMyPe(),
-            slot,slot+nslots-1,addr);
+      slot,slot+nslots-1,addr);
 #endif
 }
 
 #endif
 }
 
@@ -1642,6 +1645,10 @@ static void map_failed(CmiInt8 s,CmiInt8 n)
 
 CpvStaticDeclare(slotset *, myss); /*My managed slots*/
 
 
 CpvStaticDeclare(slotset *, myss); /*My managed slots*/
 
+#if USE_MEMPOOL_ISOMALLOC
+CtvStaticDeclare(mempool_type *, threadpool); /*Thread managed pools*/
+#endif
+
 /*This struct describes a range of virtual addresses*/
 typedef struct {
   char *start; /*First byte of region*/
 /*This struct describes a range of virtual addresses*/
 typedef struct {
   char *start; /*First byte of region*/
@@ -1665,12 +1672,12 @@ static void *__static_data_loc(void)
 
 /*Pointer comparison is in these subroutines, because
   comparing arbitrary pointers is nonportable and tricky.
 
 /*Pointer comparison is in these subroutines, because
   comparing arbitrary pointers is nonportable and tricky.
-*/
+  */
 static int pointer_lt(const char *a,const char *b) {
 static int pointer_lt(const char *a,const char *b) {
-       return ((memRange_t)a)<((memRange_t)b);
+  return ((memRange_t)a)<((memRange_t)b);
 }
 static int pointer_ge(const char *a,const char *b) {
 }
 static int pointer_ge(const char *a,const char *b) {
-       return ((memRange_t)a)>=((memRange_t)b);
+  return ((memRange_t)a)>=((memRange_t)b);
 }
 
 static char *pmin(char *a,char *b) {return pointer_lt(a,b)?a:b;}
 }
 
 static char *pmin(char *a,char *b) {return pointer_lt(a,b)?a:b;}
@@ -1681,7 +1688,7 @@ const static memRange_t gig=1024u*1024u*1024u; /*One gigabyte*/
 
 /*Check if this memory location is usable.  
   If not, return 1.
 
 /*Check if this memory location is usable.  
   If not, return 1.
-*/
+  */
 static int bad_location(char *loc) {
   void *addr;
   addr=call_mmap_fixed(loc,slotsize);
 static int bad_location(char *loc) {
   void *addr;
   addr=call_mmap_fixed(loc,slotsize);
@@ -1697,7 +1704,7 @@ static int bad_location(char *loc) {
 
 /* Split this range up into n pieces, returning the size of each piece */
 static memRange_t divide_range(memRange_t len,int n) {
 
 /* Split this range up into n pieces, returning the size of each piece */
 static memRange_t divide_range(memRange_t len,int n) {
-       return (len+1)/n;
+  return (len+1)/n;
 }
 
 /* Return if this memory region has *any* good parts. */
 }
 
 /* Return if this memory region has *any* good parts. */
@@ -1728,7 +1735,7 @@ static int good_range(char *start,memRange_t len,int n) {
 
 /*Check if this entire memory range, or some subset 
   of the range, is usable.  If so, write it into max.
 
 /*Check if this entire memory range, or some subset 
   of the range, is usable.  If so, write it into max.
-*/
+  */
 static void check_range(char *start,char *end,memRegion_t *max)
 {
   memRange_t len;
 static void check_range(char *start,char *end,memRegion_t *max)
 {
   memRange_t len;
@@ -1737,13 +1744,13 @@ static void check_range(char *start,char *end,memRegion_t *max)
 
   if (start>=end) return; /*Ran out of hole*/
   len=(memRange_t)end-(memRange_t)start;
 
   if (start>=end) return; /*Ran out of hole*/
   len=(memRange_t)end-(memRange_t)start;
-  
+
 #if 0
 #if 0
-    /* too conservative */
+  /* too conservative */
   if (len/gig>64u) { /* This is an absurd amount of space-- cut it down, for safety */
   if (len/gig>64u) { /* This is an absurd amount of space-- cut it down, for safety */
-     start+=16u*gig;
-     end=start+32u*gig;
-     len=(memRange_t)end-(memRange_t)start;  
+    start+=16u*gig;
+    end=start+32u*gig;
+    len=(memRange_t)end-(memRange_t)start;  
   }
 #else
   /* Note: 256TB == 248 bytes.  So a 48-bit virtual-address CPU 
   }
 #else
   /* Note: 256TB == 248 bytes.  So a 48-bit virtual-address CPU 
@@ -1759,7 +1766,7 @@ static void check_range(char *start,char *end,memRegion_t *max)
 #if CMK_THREADS_DEBUG
   CmiPrintf("[%d] Checking at %p - %p\n",CmiMyPe(),start,end);
 #endif
 #if CMK_THREADS_DEBUG
   CmiPrintf("[%d] Checking at %p - %p\n",CmiMyPe(),start,end);
 #endif
-  
+
   /* Check the middle of the range */
   if (!good_range(start,len,256)) {
     /* Try to split into subranges: */
   /* Check the middle of the range */
   if (!good_range(start,len,256)) {
     /* Try to split into subranges: */
@@ -1769,9 +1776,9 @@ static void check_range(char *start,char *end,memRegion_t *max)
 #endif
     len=divide_range(len,n);
     for (i=0;i<n;i++) {
 #endif
     len=divide_range(len,n);
     for (i=0;i<n;i++) {
-        char *cur=start+i*len;
-       if (partially_good(cur,len,16))
-          check_range(cur,cur+len,max);
+      char *cur=start+i*len;
+      if (partially_good(cur,len,16))
+        check_range(cur,cur+len,max);
     }
     return; /* Hopefully one of the subranges will be any good */
   }
     }
     return; /* Hopefully one of the subranges will be any good */
   }
@@ -1790,7 +1797,7 @@ static void check_range(char *start,char *end,memRegion_t *max)
 
 /*Find the first available memory region of at least the
   given size not touching any data in the used list.
 
 /*Find the first available memory region of at least the
   given size not touching any data in the used list.
- */
 */
 static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast) 
 {
   memRegion_t max;
 static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast) 
 {
   memRegion_t max;
@@ -1803,7 +1810,7 @@ static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast)
     /*Consider a hole starting at the end of region i*/
     char *holeStart=used[i].start+used[i].len;
     char *holeEnd=(void *)(-1);
     /*Consider a hole starting at the end of region i*/
     char *holeStart=used[i].start+used[i].len;
     char *holeEnd=(void *)(-1);
-    
+
     /*Shrink the hole by all others*/ 
     for (j=0;j<nUsed && pointer_lt(holeStart,holeEnd);j++) {
       if (pointer_lt(used[j].start,holeStart)) 
     /*Shrink the hole by all others*/ 
     for (j=0;j<nUsed && pointer_lt(holeStart,holeEnd);j++) {
       if (pointer_lt(used[j].start,holeStart)) 
@@ -1819,90 +1826,90 @@ static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast)
 }
 
 /*
 }
 
 /*
-By looking at the address range carefully, try to find 
-the largest usable free region on the machine.
-*/
+   By looking at the address range carefully, try to find 
+   the largest usable free region on the machine.
+   */
 static int find_largest_free_region(memRegion_t *destRegion) {
 static int find_largest_free_region(memRegion_t *destRegion) {
-    char *staticData =(char *) __static_data_loc();
-    char *code = (char *)&find_free_region;
-    char *threadData = (char *)&errno;
-    char *codeDll = (char *)fprintf;
-    char *heapLil = (char*) malloc(1);
-    char *heapBig = (char*) malloc(6*meg);
-    char *stack = (char *)__cur_stack_frame();
-    size_t mmapAnyLen = 1*meg;
-    char *mmapAny = (char*) call_mmap_anywhere(mmapAnyLen);
-
-    int i,nRegions=0;
-    memRegion_t regions[10]; /*used portions of address space*/
-    memRegion_t freeRegion; /*Largest unused block of address space*/
-
-/*Mark off regions of virtual address space as ususable*/
-    regions[nRegions].type="NULL";
-    regions[nRegions].start=NULL; 
+  char *staticData =(char *) __static_data_loc();
+  char *code = (char *)&find_free_region;
+  char *threadData = (char *)&errno;
+  char *codeDll = (char *)fprintf;
+  char *heapLil = (char*) malloc(1);
+  char *heapBig = (char*) malloc(6*meg);
+  char *stack = (char *)__cur_stack_frame();
+  size_t mmapAnyLen = 1*meg;
+  char *mmapAny = (char*) call_mmap_anywhere(mmapAnyLen);
+
+  int i,nRegions=0;
+  memRegion_t regions[10]; /*used portions of address space*/
+  memRegion_t freeRegion; /*Largest unused block of address space*/
+
+  /*Mark off regions of virtual address space as ususable*/
+  regions[nRegions].type="NULL";
+  regions[nRegions].start=NULL; 
 #if CMK_POWER7 && CMK_64BIT
 #if CMK_POWER7 && CMK_64BIT
-    regions[nRegions++].len=2u*gig;   /* on bluedrop, don't mess with the lower memory region */
+  regions[nRegions++].len=2u*gig;   /* on bluedrop, don't mess with the lower memory region */
 #else
 #else
-    regions[nRegions++].len=16u*meg;
+  regions[nRegions++].len=16u*meg;
 #endif
 #endif
-           
-    regions[nRegions].type="Static program data";
-    regions[nRegions].start=staticData; regions[nRegions++].len=256u*meg;
 
 
-    regions[nRegions].type="Program executable code";
-    regions[nRegions].start=code; regions[nRegions++].len=256u*meg;
+  regions[nRegions].type="Static program data";
+  regions[nRegions].start=staticData; regions[nRegions++].len=256u*meg;
 
 
-    regions[nRegions].type="Heap (small blocks)";
-    regions[nRegions].start=heapLil; regions[nRegions++].len=1u*gig;
+  regions[nRegions].type="Program executable code";
+  regions[nRegions].start=code; regions[nRegions++].len=256u*meg;
 
 
-    regions[nRegions].type="Heap (large blocks)";
-    regions[nRegions].start=heapBig; regions[nRegions++].len=1u*gig;
+  regions[nRegions].type="Heap (small blocks)";
+  regions[nRegions].start=heapLil; regions[nRegions++].len=1u*gig;
 
 
-    regions[nRegions].type="Stack space";
-    regions[nRegions].start=stack; regions[nRegions++].len=256u*meg;
+  regions[nRegions].type="Heap (large blocks)";
+  regions[nRegions].start=heapBig; regions[nRegions++].len=1u*gig;
 
 
-    regions[nRegions].type="Program dynamically linked code";
-    regions[nRegions].start=codeDll; regions[nRegions++].len=256u*meg; 
+  regions[nRegions].type="Stack space";
+  regions[nRegions].start=stack; regions[nRegions++].len=256u*meg;
 
 
-    regions[nRegions].type="Result of a non-fixed call to mmap";
-    regions[nRegions].start=mmapAny; regions[nRegions++].len=2u*gig; 
+  regions[nRegions].type="Program dynamically linked code";
+  regions[nRegions].start=codeDll; regions[nRegions++].len=256u*meg; 
 
 
-    regions[nRegions].type="Thread private data";
-    regions[nRegions].start=threadData; regions[nRegions++].len=256u*meg; 
+  regions[nRegions].type="Result of a non-fixed call to mmap";
+  regions[nRegions].start=mmapAny; regions[nRegions++].len=2u*gig; 
 
 
-    _MEMCHECK(heapBig); free(heapBig);
-    _MEMCHECK(heapLil); free(heapLil); 
-    call_munmap(mmapAny,mmapAnyLen);
-    
-    /*Align each memory region*/
-    for (i=0;i<nRegions;i++) {
-      memRegion_t old=regions[i];
-      memRange_t p=(memRange_t)regions[i].start;
-      p&=~(regions[i].len-1); /*Round start down to a len-boundary (mask off low bits)*/
-      regions[i].start=(char *)p;
+  regions[nRegions].type="Thread private data";
+  regions[nRegions].start=threadData; regions[nRegions++].len=256u*meg; 
+
+  _MEMCHECK(heapBig); free(heapBig);
+  _MEMCHECK(heapLil); free(heapLil); 
+  call_munmap(mmapAny,mmapAnyLen);
+
+  /*Align each memory region*/
+  for (i=0;i<nRegions;i++) {
+    memRegion_t old=regions[i];
+    memRange_t p=(memRange_t)regions[i].start;
+    p&=~(regions[i].len-1); /*Round start down to a len-boundary (mask off low bits)*/
+    regions[i].start=(char *)p;
 #if CMK_MACOSX
 #if CMK_MACOSX
-      if (regions[i].start+regions[i].len*2>regions[i].start) regions[i].len *= 2;
+    if (regions[i].start+regions[i].len*2>regions[i].start) regions[i].len *= 2;
 #endif
 #if CMK_THREADS_DEBUG
 #endif
 #if CMK_THREADS_DEBUG
-      CmiPrintf("[%d] Memory map: %p - %p (len: %lu => %lu) %s \n",CmiMyPe(),
-             regions[i].start,regions[i].start+regions[i].len,
-             old.len, regions[i].len, regions[i].type);
+    CmiPrintf("[%d] Memory map: %p - %p (len: %lu => %lu) %s \n",CmiMyPe(),
+        regions[i].start,regions[i].start+regions[i].len,
+        old.len, regions[i].len, regions[i].type);
 #endif
 #endif
-    }
-    
-    /*Find a large, unused region in this map: */
-    freeRegion=find_free_region(regions,nRegions,(512u)*meg);
-    
-    if (freeRegion.start==0) 
-    { /*No free address space-- disable isomalloc:*/
-      return 0;
-    }
-    else /* freeRegion is valid */
-    {
-      *destRegion=freeRegion;
-      
-      return 1;
-    }
+  }
+
+  /*Find a large, unused region in this map: */
+  freeRegion=find_free_region(regions,nRegions,(512u)*meg);
+
+  if (freeRegion.start==0) 
+  { /*No free address space-- disable isomalloc:*/
+    return 0;
+  }
+  else /* freeRegion is valid */
+  {
+    *destRegion=freeRegion;
+
+    return 1;
+  }
 }
 
 static int try_largest_mmap_region(memRegion_t *destRegion)
 }
 
 static int try_largest_mmap_region(memRegion_t *destRegion)
@@ -1916,53 +1923,53 @@ static int try_largest_mmap_region(memRegion_t *destRegion)
   if (sizeof(size_t) >= 8) size = size>>2;  /* 25% of machine address space! */
   while (1) { /* test out an allocation of this size */
 #if CMK_HAS_MMAP
   if (sizeof(size_t) >= 8) size = size>>2;  /* 25% of machine address space! */
   while (1) { /* test out an allocation of this size */
 #if CMK_HAS_MMAP
-       range=mmap(NULL,size,PROT_READ|PROT_WRITE,
-                    MAP_PRIVATE
+    range=mmap(NULL,size,PROT_READ|PROT_WRITE,
+        MAP_PRIVATE
 #if CMK_HAS_MMAP_ANON
 #if CMK_HAS_MMAP_ANON
-                    |MAP_ANON
+        |MAP_ANON
 #endif
 #if CMK_HAS_MMAP_NORESERVE
 #endif
 #if CMK_HAS_MMAP_NORESERVE
-                     |MAP_NORESERVE
+        |MAP_NORESERVE
 #endif
 #endif
-                     ,-1,0);
+        ,-1,0);
 #else
 #else
-        range = bad_alloc;
+    range = bad_alloc;
 #endif
 #endif
-        if (range == bad_alloc) {  /* mmap failed */
+    if (range == bad_alloc) {  /* mmap failed */
 #if CMK_THREADS_DEBUG
 #if CMK_THREADS_DEBUG
-                /* CmiPrintf("[%d] test failed at size: %llu error: %d\n", CmiMyPe(), size, errno);  */
+      /* CmiPrintf("[%d] test failed at size: %llu error: %d\n", CmiMyPe(), size, errno);  */
 #endif
 #if CMK_HAS_USLEEP
 #endif
 #if CMK_HAS_USLEEP
-                if (retry++ < 5) { usleep(rand()%10000); continue; }
-                else retry = 0;
+      if (retry++ < 5) { usleep(rand()%10000); continue; }
+      else retry = 0;
 #endif
 #endif
-               size=(double)size/shrink; /* shrink request */
-               if (size<=0) return 0; /* mmap doesn't work */
-       }
-       else { /* this allocation size is available */
+      size=(double)size/shrink; /* shrink request */
+      if (size<=0) return 0; /* mmap doesn't work */
+    }
+    else { /* this allocation size is available */
 #if CMK_THREADS_DEBUG
 #if CMK_THREADS_DEBUG
-               CmiPrintf("[%d] available: %p, %lld\n", CmiMyPe(), range, size);
+      CmiPrintf("[%d] available: %p, %lld\n", CmiMyPe(), range, size);
 #endif
 #endif
-              call_munmap(range,size); /* needed/wanted? */
-               if (size > good_size) {
-                 good_range = range;
-                 good_size = size;
-                 size=((double)size)*1.1;
-                 continue;
-               }
-               break;
-       }
+      call_munmap(range,size); /* needed/wanted? */
+      if (size > good_size) {
+        good_range = range;
+        good_size = size;
+        size=((double)size)*1.1;
+        continue;
+      }
+      break;
+    }
   }
   CmiAssert(good_range!=NULL);
   destRegion->start=good_range; 
   destRegion->len=good_size;
 #if CMK_THREADS_DEBUG
   }
   CmiAssert(good_range!=NULL);
   destRegion->start=good_range; 
   destRegion->len=good_size;
 #if CMK_THREADS_DEBUG
-pid_t pid = getpid();
-{
-char s[128];
-sprintf(s, "cat /proc/%d/maps", pid);
-system(s);
-}
+  pid_t pid = getpid();
+  {
+    char s[128];
+    sprintf(s, "cat /proc/%d/maps", pid);
+    system(s);
+  }
   CmiPrintf("[%d] try_largest_mmap_region: %p, %lld\n", CmiMyPe(), good_range, good_size);
 #endif
   return 1;
   CmiPrintf("[%d] try_largest_mmap_region: %p, %lld\n", CmiMyPe(), good_range, good_size);
 #endif
   return 1;
@@ -1990,168 +1997,173 @@ static void init_ranges(char **argv)
 
 #if CMK_THREADS_DEBUG
   if (CmiMyPe() == 0)
 
 #if CMK_THREADS_DEBUG
   if (CmiMyPe() == 0)
-  CmiPrintf("[%d] Using slotsize of %d\n", CmiMyPe(), slotsize);
+    CmiPrintf("[%d] Using slotsize of %d\n", CmiMyPe(), slotsize);
 #endif
   freeRegion.len=0u;
 
   if (CmiMyRank()==0 && numslots==0)
   { /* Find the largest unused region of virtual address space */
 #ifdef CMK_MMAP_START_ADDRESS /* Hardcoded start address, for machines where automatic fails */
 #endif
   freeRegion.len=0u;
 
   if (CmiMyRank()==0 && numslots==0)
   { /* Find the largest unused region of virtual address space */
 #ifdef CMK_MMAP_START_ADDRESS /* Hardcoded start address, for machines where automatic fails */
-      freeRegion.start=CMK_MMAP_START_ADDRESS;
-      freeRegion.len=CMK_MMAP_LENGTH_MEGS*meg;
+    freeRegion.start=CMK_MMAP_START_ADDRESS;
+    freeRegion.len=CMK_MMAP_LENGTH_MEGS*meg;
 #endif
 #endif
-      
-      if (freeRegion.len==0u)  {
-        if (_mmap_probe == 1) {
-          if (try_largest_mmap_region(&freeRegion)) _sync_iso = 1;
-        }
-        else {
-          if (freeRegion.len==0u) find_largest_free_region(&freeRegion);
-        }
+
+    if (freeRegion.len==0u)  {
+      if (_mmap_probe == 1) {
+        if (try_largest_mmap_region(&freeRegion)) _sync_iso = 1;
       }
       }
+      else {
+        if (freeRegion.len==0u) find_largest_free_region(&freeRegion);
+      }
+    }
 
 #if 0
 
 #if 0
-      /*Make sure our largest slot number doesn't overflow an int:*/
-      if (freeRegion.len/slotsize>intMax)
-        freeRegion.len=intMax*slotsize;
+    /*Make sure our largest slot number doesn't overflow an int:*/
+    if (freeRegion.len/slotsize>intMax)
+      freeRegion.len=intMax*slotsize;
 #endif
 #endif
-      
-      if (freeRegion.len==0u) {
-        disable_isomalloc("no free virtual address space");
-      }
-      else /* freeRegion.len>0, so can isomalloc */
-      {
+
+    if (freeRegion.len==0u) {
+      disable_isomalloc("no free virtual address space");
+    }
+    else /* freeRegion.len>0, so can isomalloc */
+    {
 #if CMK_THREADS_DEBUG
 #if CMK_THREADS_DEBUG
-        CmiPrintf("[%d] Isomalloc memory region: %p - %p (%d megs)\n",CmiMyPe(),
-             freeRegion.start,freeRegion.start+freeRegion.len,
-             freeRegion.len/meg);
+      CmiPrintf("[%d] Isomalloc memory region: %p - %p (%d megs)\n",CmiMyPe(),
+          freeRegion.start,freeRegion.start+freeRegion.len,
+          freeRegion.len/meg);
 #endif
 #endif
-      }
+    }
   }             /* end if myrank == 0 */
 
   CmiNodeAllBarrier();
 
   }             /* end if myrank == 0 */
 
   CmiNodeAllBarrier();
 
-    /*
-       on some machines, isomalloc memory regions on different nodes 
-       can be different. use +isomalloc_sync to calculate the
-       intersect of all memory regions on all nodes.
-    */
+  /*
+     on some machines, isomalloc memory regions on different nodes 
+     can be different. use +isomalloc_sync to calculate the
+     intersect of all memory regions on all nodes.
+     */
   if (_sync_iso == 1)
   {
   if (_sync_iso == 1)
   {
-        if (CmiMyRank() == 0 && freeRegion.len > 0u) {
-          if (CmiBarrier() == -1 && CmiMyPe()==0) 
-            CmiAbort("Charm++ Error> +isomalloc_sync requires CmiBarrier() implemented.\n");
-          else {
-            CmiUInt8 s = (CmiUInt8)freeRegion.start;
-            CmiUInt8 e = (CmiUInt8)(freeRegion.start+freeRegion.len);
-            int fd, i;
-            char fname[128];
+    if (CmiMyRank() == 0 && freeRegion.len > 0u) {
+      if (CmiBarrier() == -1 && CmiMyPe()==0) 
+        CmiAbort("Charm++ Error> +isomalloc_sync requires CmiBarrier() implemented.\n");
+      else {
+        CmiUInt8 s = (CmiUInt8)freeRegion.start;
+        CmiUInt8 e = (CmiUInt8)(freeRegion.start+freeRegion.len);
+        int fd, i;
+        char fname[128];
 
 
-            if (CmiMyNode()==0) printf("Charm++> synchronizing isomalloc memory region...\n");
+        if (CmiMyNode()==0) printf("Charm++> synchronizing isomalloc memory region...\n");
 
 
-            sprintf(fname,".isomalloc.%d", CmiMyNode());
+        sprintf(fname,".isomalloc.%d", CmiMyNode());
 
 
-              /* remove file before writing for safe */
-            unlink(fname);
+        /* remove file before writing for safe */
+        unlink(fname);
 #if CMK_HAS_SYNC && ! CMK_DISABLE_SYNC
 #if CMK_HAS_SYNC && ! CMK_DISABLE_SYNC
-            system("sync");
+        system("sync");
 #endif
 
 #endif
 
-            CmiBarrier();
+        CmiBarrier();
 
 
-              /* write region into file */
-            while ((fd = open(fname, O_WRONLY|O_TRUNC|O_CREAT, 0644)) == -1) 
+        /* write region into file */
+        while ((fd = open(fname, O_WRONLY|O_TRUNC|O_CREAT, 0644)) == -1) 
 #ifndef __MINGW_H
 #ifndef __MINGW_H
-              CMK_CPV_IS_SMP
+          CMK_CPV_IS_SMP
 #endif
             ;
 #endif
             ;
-            write(fd, &s, sizeof(CmiUInt8));
-            write(fd, &e, sizeof(CmiUInt8));
-            close(fd);
+        write(fd, &s, sizeof(CmiUInt8));
+        write(fd, &e, sizeof(CmiUInt8));
+        close(fd);
 
 #if CMK_HAS_SYNC && ! CMK_DISABLE_SYNC
 
 #if CMK_HAS_SYNC && ! CMK_DISABLE_SYNC
-            system("sync");
+        system("sync");
 #endif
 
 #endif
 
-            CmiBarrier();
-
-            for (i=0; i<CmiNumNodes(); i++) {
-              CmiUInt8 ss, ee; 
-              int try_count;
-              char fname[128];
-              if (i==CmiMyNode()) continue;
-              sprintf(fname,".isomalloc.%d", i);
-              try_count = 0;
-              while ((fd = open(fname, O_RDONLY)) == -1 && try_count<10000)
-              {
-                try_count++;
+        CmiBarrier();
+
+        for (i=0; i<CmiNumNodes(); i++) {
+          CmiUInt8 ss, ee; 
+          int try_count;
+          char fname[128];
+          if (i==CmiMyNode()) continue;
+          sprintf(fname,".isomalloc.%d", i);
+          try_count = 0;
+          while ((fd = open(fname, O_RDONLY)) == -1 && try_count<10000)
+          {
+            try_count++;
 #ifndef __MINGW_H
 #ifndef __MINGW_H
-                CMK_CPV_IS_SMP
+            CMK_CPV_IS_SMP
 #endif
 #endif
-                ;
-              }
-              if (fd == -1) {
-                CmiAbort("isomalloc_sync failed, make sure you have a shared file system.");
-              }
-              read(fd, &ss, sizeof(CmiUInt8));
-              read(fd, &ee, sizeof(CmiUInt8));
+              ;
+          }
+          if (fd == -1) {
+            CmiAbort("isomalloc_sync failed, make sure you have a shared file system.");
+          }
+          read(fd, &ss, sizeof(CmiUInt8));
+          read(fd, &ee, sizeof(CmiUInt8));
 #if CMK_THREADS_DEBUG
 #if CMK_THREADS_DEBUG
-              if (CmiMyPe() == 0) CmiPrintf("[%d] load node %d isomalloc region: %lx %lx. \n",
-                               CmiMyPe(), i, ss, ee);
+          if (CmiMyPe() == 0) CmiPrintf("[%d] load node %d isomalloc region: %lx %lx. \n",
+              CmiMyPe(), i, ss, ee);
 #endif
 #endif
-              close(fd);
-              if (ss>s) s = ss;
-              if (ee<e) e = ee;
-            }
+          close(fd);
+          if (ss>s) s = ss;
+          if (ee<e) e = ee;
+        }
 
 
-            CmiBarrier();
+        CmiBarrier();
 
 
-            unlink(fname);
+        unlink(fname);
 #if CMK_HAS_SYNC && ! CMK_DISABLE_SYNC
 #if CMK_HAS_SYNC && ! CMK_DISABLE_SYNC
-            system("sync");
+        system("sync");
 #endif
 
 #endif
 
-              /* update */
-            if (s > e)  {
-              if (CmiMyPe()==0) CmiPrintf("[%d] Invalid isomalloc region: %lx - %lx.\n", CmiMyPe(), s, e);
-              CmiAbort("isomalloc> failed to find consolidated isomalloc region!");
-            }
-            freeRegion.start = (void *)s;
-            freeRegion.len = (char *)e -(char *)s;
-
-            if (CmiMyPe() == 0)
-            CmiPrintf("[%d] consolidated Isomalloc memory region: %p - %p (%d megs)\n",CmiMyPe(),
-             freeRegion.start,freeRegion.start+freeRegion.len,
-             freeRegion.len/meg);
-          }   /* end of barrier test */
-        } /* end of rank 0 */
-        else {
-          CmiBarrier();
-          CmiBarrier();
-          CmiBarrier();
-          CmiBarrier();
+        /* update */
+        if (s > e)  {
+          if (CmiMyPe()==0) CmiPrintf("[%d] Invalid isomalloc region: %lx - %lx.\n", CmiMyPe(), s, e);
+          CmiAbort("isomalloc> failed to find consolidated isomalloc region!");
         }
         }
+        freeRegion.start = (void *)s;
+        freeRegion.len = (char *)e -(char *)s;
+
+        if (CmiMyPe() == 0)
+          CmiPrintf("[%d] consolidated Isomalloc memory region: %p - %p (%d megs)\n",CmiMyPe(),
+              freeRegion.start,freeRegion.start+freeRegion.len,
+              freeRegion.len/meg);
+      }   /* end of barrier test */
+    } /* end of rank 0 */
+    else {
+      CmiBarrier();
+      CmiBarrier();
+      CmiBarrier();
+      CmiBarrier();
+    }
   }
 
   if (CmiMyRank() == 0 && freeRegion.len > 0u)
   {
   }
 
   if (CmiMyRank() == 0 && freeRegion.len > 0u)
   {
-        /*Isomalloc covers entire unused region*/
-        isomallocStart=freeRegion.start;
-        isomallocEnd=freeRegion.start+freeRegion.len;
-        numslots=(freeRegion.len/slotsize)/CmiNumPes();
+    /*Isomalloc covers entire unused region*/
+    isomallocStart=freeRegion.start;
+    isomallocEnd=freeRegion.start+freeRegion.len;
+    numslots=(freeRegion.len/slotsize)/CmiNumPes();
 
 #if CMK_THREADS_DEBUG
 
 #if CMK_THREADS_DEBUG
-        CmiPrintf("[%d] Can isomalloc up to %lu megs per pe\n",CmiMyPe(),
-             ((memRange_t)numslots)*slotsize/meg);
+    CmiPrintf("[%d] Can isomalloc up to %lu megs per pe\n",CmiMyPe(),
+        ((memRange_t)numslots)*slotsize/meg);
 #endif
   }
 
   /*SMP Mode: wait here for rank 0 to initialize numslots before calculating myss*/
   CmiNodeAllBarrier(); 
 #endif
   }
 
   /*SMP Mode: wait here for rank 0 to initialize numslots before calculating myss*/
   CmiNodeAllBarrier(); 
+
   CpvInitialize(slotset *, myss);
   CpvAccess(myss) = NULL;
   CpvInitialize(slotset *, myss);
   CpvAccess(myss) = NULL;
+
+#if USE_MEMPOOL_ISOMALLOC
+  CtvInitialize(mempool_type *, threadpool);
+  CtvAccess(threadpool) = NULL;
+#endif
+
   if (isomallocStart!=NULL) {
     CpvAccess(myss) = new_slotset(pe2slot(CmiMyPe()), numslots);
   }
   if (isomallocStart!=NULL) {
     CpvAccess(myss) = new_slotset(pe2slot(CmiMyPe()), numslots);
   }
@@ -2169,107 +2181,107 @@ typedef struct _slotmsg
 
 static slotmsg *prepare_slotmsg(CmiInt8 slot,CmiInt8 nslots)
 {
 
 static slotmsg *prepare_slotmsg(CmiInt8 slot,CmiInt8 nslots)
 {
-       slotmsg *m=(slotmsg *)CmiAlloc(sizeof(slotmsg));
-       m->pe=CmiMyPe();
-       m->slot=slot;
-       m->nslots=nslots;
-       return m;
+  slotmsg *m=(slotmsg *)CmiAlloc(sizeof(slotmsg));
+  m->pe=CmiMyPe();
+  m->slot=slot;
+  m->nslots=nslots;
+  return m;
 }
 
 static void grab_remote(slotmsg *msg)
 {
 }
 
 static void grab_remote(slotmsg *msg)
 {
-       grab_slots(CpvAccess(myss),msg->slot,msg->nslots);
-       CmiFree(msg);
+  grab_slots(CpvAccess(myss),msg->slot,msg->nslots);
+  CmiFree(msg);
 }
 
 static void free_remote(slotmsg *msg)
 {
 }
 
 static void free_remote(slotmsg *msg)
 {
-       free_slots(CpvAccess(myss),msg->slot,msg->nslots);
-       CmiFree(msg);
+  free_slots(CpvAccess(myss),msg->slot,msg->nslots);
+  CmiFree(msg);
 }
 static int grab_remote_idx, free_remote_idx;
 
 struct slotOP {
 }
 static int grab_remote_idx, free_remote_idx;
 
 struct slotOP {
-       /*Function pointer to perform local operation*/
-       void (*local)(slotset *ss,CmiInt8 s,CmiInt8 n);
-       /*Index to perform remote operation*/
-       int remote;
+  /*Function pointer to perform local operation*/
+  void (*local)(slotset *ss,CmiInt8 s,CmiInt8 n);
+  /*Index to perform remote operation*/
+  int remote;
 };
 typedef struct slotOP slotOP;
 static slotOP grabOP,freeOP;
 
 static void init_comm(char **argv)
 {
 };
 typedef struct slotOP slotOP;
 static slotOP grabOP,freeOP;
 
 static void init_comm(char **argv)
 {
-       grab_remote_idx=CmiRegisterHandler((CmiHandler)grab_remote);
-       free_remote_idx=CmiRegisterHandler((CmiHandler)free_remote);    
-       grabOP.local=grab_slots;
-       grabOP.remote=grab_remote_idx;
-       freeOP.local=free_slots;
-       freeOP.remote=free_remote_idx;  
+  grab_remote_idx=CmiRegisterHandler((CmiHandler)grab_remote);
+  free_remote_idx=CmiRegisterHandler((CmiHandler)free_remote); 
+  grabOP.local=grab_slots;
+  grabOP.remote=grab_remote_idx;
+  freeOP.local=free_slots;
+  freeOP.remote=free_remote_idx;       
 }
 
 /*Apply the given operation to the given slots which
   lie on the given processor.*/
 static void one_slotOP(const slotOP *op,int pe,CmiInt8 s,CmiInt8 n)
 {
 }
 
 /*Apply the given operation to the given slots which
   lie on the given processor.*/
 static void one_slotOP(const slotOP *op,int pe,CmiInt8 s,CmiInt8 n)
 {
-/*Shrink range to only those covered by this processor*/
-       /*First and last slot for this processor*/
-       CmiInt8 p_s=pe2slot(pe), p_e=pe2slot(pe+1);
-       CmiInt8 e=s+n;
-       if (s<p_s) s=p_s;
-       if (e>p_e) e=p_e;
-       n=e-s;
-
-/*Send off range*/
-       if (pe==CmiMyPe()) 
-               op->local(CpvAccess(myss),s,n);
-       else 
-       {/*Remote request*/
-               slotmsg *m=prepare_slotmsg(s,n);
-               CmiSetHandler(m, freeOP.remote);
-               CmiSyncSendAndFree(pe,sizeof(slotmsg),m);
-       }
+  /*Shrink range to only those covered by this processor*/
+  /*First and last slot for this processor*/
+  CmiInt8 p_s=pe2slot(pe), p_e=pe2slot(pe+1);
+  CmiInt8 e=s+n;
+  if (s<p_s) s=p_s;
+  if (e>p_e) e=p_e;
+  n=e-s;
+
+  /*Send off range*/
+  if (pe==CmiMyPe()) 
+    op->local(CpvAccess(myss),s,n);
+  else 
+  {/*Remote request*/
+    slotmsg *m=prepare_slotmsg(s,n);
+    CmiSetHandler(m, freeOP.remote);
+    CmiSyncSendAndFree(pe,sizeof(slotmsg),m);
+  }
 }
 
 /*Apply the given operation to all slots in the range [s, s+n) 
 }
 
 /*Apply the given operation to all slots in the range [s, s+n) 
-After a restart from checkpoint, a slotset can cross an 
-arbitrary set of processors.
-*/
+  After a restart from checkpoint, a slotset can cross an 
+  arbitrary set of processors.
+  */
 static void all_slotOP(const slotOP *op,CmiInt8 s,CmiInt8 n)
 {
 static void all_slotOP(const slotOP *op,CmiInt8 s,CmiInt8 n)
 {
-       int spe=slot2pe(s), epe=slot2pe(s+n-1);
-       int pe;
-       for (pe=spe; pe<=epe; pe++)
-               one_slotOP(op,pe,s,n);
+  int spe=slot2pe(s), epe=slot2pe(s+n-1);
+  int pe;
+  for (pe=spe; pe<=epe; pe++)
+    one_slotOP(op,pe,s,n);
 }
 
 /************** External interface ***************/
 void *CmiIsomalloc(int size)
 {
 }
 
 /************** External interface ***************/
 void *CmiIsomalloc(int size)
 {
-       CmiInt8 s,n,i;
-       CmiIsomallocBlock *blk;
-       if (isomallocStart==NULL) return disabled_map(size);
-       n=length2slots(size);
-       /*Always satisfy mallocs with local slots:*/
-       s=get_slots(CpvAccess(myss),n);
-       if (s==-1) {
-               CmiError("Not enough address space left on processor %d to isomalloc %d bytes!\n",
-                        CmiMyPe(),size);
-               CmiAbort("Out of virtual address space for isomalloc");
-       }
-       grab_slots(CpvAccess(myss),s,n);
-        for (i=0; i<5; i++) {
-         blk=map_slots(s,n);
-          if (blk!=NULL) break;
+  CmiInt8 s,n,i;
+  CmiIsomallocBlock *blk;
+  if (isomallocStart==NULL) return disabled_map(size);
+  n=length2slots(size);
+  /*Always satisfy mallocs with local slots:*/
+  s=get_slots(CpvAccess(myss),n);
+  if (s==-1) {
+    CmiError("Not enough address space left on processor %d to isomalloc %d bytes!\n",
+        CmiMyPe(),size);
+    CmiAbort("Out of virtual address space for isomalloc");
+  }
+  grab_slots(CpvAccess(myss),s,n);
+  for (i=0; i<5; i++) {
+    blk=map_slots(s,n);
+    if (blk!=NULL) break;
 #if CMK_HAS_USLEEP
 #if CMK_HAS_USLEEP
-          if (errno == ENOMEM) { usleep(rand()%1000); continue; }
-          else break;
+    if (errno == ENOMEM) { usleep(rand()%1000); continue; }
+    else break;
 #endif
 #endif
-        }
-       if (!blk) map_failed(s,n);
-       blk->slot=s;
-       blk->length=size;
-       return block2pointer(blk);
+  }
+  if (!blk) map_failed(s,n);
+  blk->slot=s;
+  blk->length=size;
+  return block2pointer(blk);
 }
 
 #define MALLOC_ALIGNMENT           (2*sizeof(size_t))
 }
 
 #define MALLOC_ALIGNMENT           (2*sizeof(size_t))
@@ -2280,31 +2292,31 @@ void *CmiIsomalloc(int size)
  */
 static void *_isomallocAlign(size_t align, size_t size, size_t reserved)
 {
  */
 static void *_isomallocAlign(size_t align, size_t size, size_t reserved)
 {
-        void *ptr;
-        CmiIntPtr ptr2align;
-        CmiInt8 s;
-
-        if (align < MINSIZE) align = MINSIZE;
-        /* make sure alignment is power of 2 */
-        if ((align & (align - 1)) != 0) {
-          size_t a = MALLOC_ALIGNMENT * 2;
-          while ((unsigned long)a < (unsigned long)align) a <<= 1;
-          align = a;
-        }
-        s = size + reserved + align;
-        ptr = CmiIsomalloc(s);
-        ptr2align = (CmiIntPtr)ptr;
-        ptr2align += reserved;
-        if (ptr2align % align != 0) { /* misaligned */
-          CmiIsomallocBlock *blk = pointer2block(ptr);  /* save block */
-          CmiIsomallocBlock savedblk = *blk;
-          ptr2align = (ptr2align + align - 1) & -((CmiInt8) align);
-          ptr2align -= reserved;
-          ptr = (void*)ptr2align;
-          blk = pointer2block(ptr);      /* restore block */
-          *blk = savedblk;
-        }
-       return ptr;
+  void *ptr;
+  CmiIntPtr ptr2align;
+  CmiInt8 s;
+
+  if (align < MINSIZE) align = MINSIZE;
+  /* make sure alignment is power of 2 */
+  if ((align & (align - 1)) != 0) {
+    size_t a = MALLOC_ALIGNMENT * 2;
+    while ((unsigned long)a < (unsigned long)align) a <<= 1;
+    align = a;
+  }
+  s = size + reserved + align;
+  ptr = CmiIsomalloc(s);
+  ptr2align = (CmiIntPtr)ptr;
+  ptr2align += reserved;
+  if (ptr2align % align != 0) { /* misaligned */
+    CmiIsomallocBlock *blk = pointer2block(ptr);  /* save block */
+    CmiIsomallocBlock savedblk = *blk;
+    ptr2align = (ptr2align + align - 1) & -((CmiInt8) align);
+    ptr2align -= reserved;
+    ptr = (void*)ptr2align;
+    blk = pointer2block(ptr);      /* restore block */
+    *blk = savedblk;
+  }
+  return ptr;
 }
 
 void *CmiIsomallocAlign(size_t align, size_t size)
 }
 
 void *CmiIsomallocAlign(size_t align, size_t size)
@@ -2319,72 +2331,72 @@ int CmiIsomallocEnabled()
 
 void CmiIsomallocPup(pup_er p,void **blockPtrPtr)
 {
 
 void CmiIsomallocPup(pup_er p,void **blockPtrPtr)
 {
-       CmiIsomallocBlock *blk;
-       CmiInt8 s,length;
-        CmiInt8 n;
-       if (isomallocStart==NULL) CmiAbort("isomalloc is disabled-- cannot use IsomallocPup");
-
-       if (!pup_isUnpacking(p)) 
-       { /*We have an existing block-- unpack start slot & length*/
-               blk=pointer2block(*blockPtrPtr);
-               s=blk->slot;
-               length=blk->length;
-       }
-       
-       pup_int8(p,&s);
-       pup_int8(p,&length);
-       n=length2slots(length);
-       
-       if (pup_isUnpacking(p)) 
-       { /*Must allocate a new block in its old location*/
-               if (pup_isUserlevel(p) || pup_isRestarting(p))
-               {       /*Checkpoint: must grab old slots (even remote!)*/
-                       all_slotOP(&grabOP,s,n);
-               }
-               blk=map_slots(s,n);
-               if (!blk) map_failed(s,n);
-               blk->slot=s;
-               blk->length=length;
-               *blockPtrPtr=block2pointer(blk);
-       }
-       
-       /*Pup the allocated data*/
-       pup_bytes(p,*blockPtrPtr,length);
-       
-       if (pup_isDeleting(p)) 
-       { /*Unmap old slots, but do not mark as free*/
-               unmap_slots(s,n);
-               *blockPtrPtr=NULL; /*Zero out user's pointer*/
-       }
+  CmiIsomallocBlock *blk;
+  CmiInt8 s,length;
+  CmiInt8 n;
+  if (isomallocStart==NULL) CmiAbort("isomalloc is disabled-- cannot use IsomallocPup");
+
+  if (!pup_isUnpacking(p)) 
+  { /*We have an existing block-- unpack start slot & length*/
+    blk=pointer2block(*blockPtrPtr);
+    s=blk->slot;
+    length=blk->length;
+  }
+
+  pup_int8(p,&s);
+  pup_int8(p,&length);
+  n=length2slots(length);
+
+  if (pup_isUnpacking(p)) 
+  { /*Must allocate a new block in its old location*/
+    if (pup_isUserlevel(p) || pup_isRestarting(p))
+    {  /*Checkpoint: must grab old slots (even remote!)*/
+      all_slotOP(&grabOP,s,n);
+    }
+    blk=map_slots(s,n);
+    if (!blk) map_failed(s,n);
+    blk->slot=s;
+    blk->length=length;
+    *blockPtrPtr=block2pointer(blk);
+  }
+
+  /*Pup the allocated data*/
+  pup_bytes(p,*blockPtrPtr,length);
+
+  if (pup_isDeleting(p)) 
+  { /*Unmap old slots, but do not mark as free*/
+    unmap_slots(s,n);
+    *blockPtrPtr=NULL; /*Zero out user's pointer*/
+  }
 }
 
 void CmiIsomallocFree(void *blockPtr)
 {
 }
 
 void CmiIsomallocFree(void *blockPtr)
 {
-       if (isomallocStart==NULL) {
-               disabled_unmap(blockPtr);
-       }
-       else if (blockPtr!=NULL)
-       {
-               CmiIsomallocBlock *blk=pointer2block(blockPtr);
-               CmiInt8 s=blk->slot; 
-                CmiInt8 n=length2slots(blk->length);
-               unmap_slots(s,n);
-               /*Mark used slots as free*/
-               all_slotOP(&freeOP,s,n);
-       }
+  if (isomallocStart==NULL) {
+    disabled_unmap(blockPtr);
+  }
+  else if (blockPtr!=NULL)
+  {
+    CmiIsomallocBlock *blk=pointer2block(blockPtr);
+    CmiInt8 s=blk->slot; 
+    CmiInt8 n=length2slots(blk->length);
+    unmap_slots(s,n);
+    /*Mark used slots as free*/
+    all_slotOP(&freeOP,s,n);
+  }
 }
 
 CmiInt8   CmiIsomallocLength(void *block)
 {
 }
 
 CmiInt8   CmiIsomallocLength(void *block)
 {
-       return pointer2block(block)->length;
+  return pointer2block(block)->length;
 }
 
 /*Return true if this address is in the region managed by isomalloc*/
 int CmiIsomallocInRange(void *addr)
 {
 }
 
 /*Return true if this address is in the region managed by isomalloc*/
 int CmiIsomallocInRange(void *addr)
 {
-       if (isomallocStart==NULL) return 0; /* There is no range we manage! */
-       return pointer_ge((char *)addr,isomallocStart) && 
-              pointer_lt((char*)addr,isomallocEnd);
+  if (isomallocStart==NULL) return 0; /* There is no range we manage! */
+  return pointer_ge((char *)addr,isomallocStart) && 
+    pointer_lt((char*)addr,isomallocEnd);
 }
 
 void CmiIsomallocInit(char **argv)
 }
 
 void CmiIsomallocInit(char **argv)
@@ -2426,10 +2438,10 @@ void CmiIsomallocInit(char **argv)
 }
 
 /***************** BlockList interface *********
 }
 
 /***************** BlockList interface *********
-This was moved here from memory-isomalloc.c when it 
-was realized that a list-of-isomalloc'd-blocks is useful for
-more than just isomalloc heaps.
-*/
+  This was moved here from memory-isomalloc.c when it 
+  was realized that a list-of-isomalloc'd-blocks is useful for
+  more than just isomalloc heaps.
+  */
 
 /*Convert a slot to a user address*/
 static char *Slot_toUser(CmiIsomallocBlockList *s) {return (char *)(s+1);}
 
 /*Convert a slot to a user address*/
 static char *Slot_toUser(CmiIsomallocBlockList *s) {return (char *)(s+1);}
@@ -2439,11 +2451,11 @@ static CmiIsomallocBlockList *Slot_fmUser(void *s) {return ((CmiIsomallocBlockLi
 /*Build a new blockList.*/
 CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
 {
 /*Build a new blockList.*/
 CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
 {
-       CmiIsomallocBlockList *ret;
-       ret=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(*ret));
-       ret->next=ret; /*1-entry circular linked list*/
-       ret->prev=ret;
-       return ret;
+  CmiIsomallocBlockList *ret;
+  ret=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(*ret));
+  ret->next=ret; /*1-entry circular linked list*/
+  ret->prev=ret;
+  return ret;
 }
 
 
 }
 
 
@@ -2451,109 +2463,109 @@ CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
 static void print_myslots();
 
 /*Pup all the blocks in this list.  This amounts to two circular
 static void print_myslots();
 
 /*Pup all the blocks in this list.  This amounts to two circular
-list traversals.  Because everything's isomalloc'd, we don't even
-have to restore the pointers-- they'll be restored automatically!
-*/
+  list traversals.  Because everything's isomalloc'd, we don't even
+  have to restore the pointers-- they'll be restored automatically!
+  */
 void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
 {
 void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
 {
-        /* BIGSIM_OOC DEBUGGING */
-       /* if(!pup_isUnpacking(p)) print_myslots(); */
+  /* BIGSIM_OOC DEBUGGING */
+  /* if(!pup_isUnpacking(p)) print_myslots(); */
 
 
-       int i,nBlocks=0;
-       CmiIsomallocBlockList *cur=NULL, *start=*lp;
+  int i,nBlocks=0;
+  CmiIsomallocBlockList *cur=NULL, *start=*lp;
 #if 0 /*#ifndef CMK_OPTIMIZE*/
 #if 0 /*#ifndef CMK_OPTIMIZE*/
-       if (CpvAccess(isomalloc_blocklist)!=NULL)
-               CmiAbort("Called CmiIsomallocBlockListPup while a blockList is active!\n"
-                       "You should swap out the active blocklist before pupping.\n");
+  if (CpvAccess(isomalloc_blocklist)!=NULL)
+    CmiAbort("Called CmiIsomallocBlockListPup while a blockList is active!\n"
+        "You should swap out the active blocklist before pupping.\n");
 #endif
 #endif
-       /*Count the number of blocks in the list*/
-       if (!pup_isUnpacking(p)) {
-               nBlocks=1; /*<- Since we have to skip the start block*/
-               for (cur=start->next; cur!=start; cur=cur->next) 
-                       nBlocks++;
-               /*Prepare for next trip around list:*/
-               cur=start;
-       }
-       pup_int(p,&nBlocks);
-       
-       /*Pup each block in the list*/
-       for (i=0;i<nBlocks;i++) {
-               void *newBlock=cur;
-               if (!pup_isUnpacking(p)) 
-               { /*While packing, we traverse the list to find our blocks*/
-                       cur=cur->next;
-               }
-               CmiIsomallocPup(p,&newBlock);
-               if (i==0 && pup_isUnpacking(p))
-                       *lp=(CmiIsomallocBlockList *)newBlock;
-       }
-       if (pup_isDeleting(p))
-               *lp=NULL;
-
-       /* BIGSIM_OOC DEBUGGING */
-       /* if(pup_isUnpacking(p)) print_myslots(); */
+  /*Count the number of blocks in the list*/
+  if (!pup_isUnpacking(p)) {
+    nBlocks=1; /*<- Since we have to skip the start block*/
+    for (cur=start->next; cur!=start; cur=cur->next) 
+      nBlocks++;
+    /*Prepare for next trip around list:*/
+    cur=start;
+  }
+  pup_int(p,&nBlocks);
+
+  /*Pup each block in the list*/
+  for (i=0;i<nBlocks;i++) {
+    void *newBlock=cur;
+    if (!pup_isUnpacking(p)) 
+    { /*While packing, we traverse the list to find our blocks*/
+      cur=cur->next;
+    }
+    CmiIsomallocPup(p,&newBlock);
+    if (i==0 && pup_isUnpacking(p))
+      *lp=(CmiIsomallocBlockList *)newBlock;
+  }
+  if (pup_isDeleting(p))
+    *lp=NULL;
+
+  /* BIGSIM_OOC DEBUGGING */
+  /* if(pup_isUnpacking(p)) print_myslots(); */
 }
 
 /*Delete all the blocks in this list.*/
 void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l)
 {
 }
 
 /*Delete all the blocks in this list.*/
 void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l)
 {
-    CmiIsomallocBlockList *start=l;
-    CmiIsomallocBlockList *cur=start;
-       if (cur==NULL) return; /*Already deleted*/
-       do {
-         CmiIsomallocBlockList *doomed=cur;
-               cur=cur->next; /*Have to stash next before deleting cur*/
-               CmiIsomallocFree(doomed);
-       } while (cur!=start);
+  CmiIsomallocBlockList *start=l;
+  CmiIsomallocBlockList *cur=start;
+  if (cur==NULL) return; /*Already deleted*/
+  do {
+    CmiIsomallocBlockList *doomed=cur;
+    cur=cur->next; /*Have to stash next before deleting cur*/
+    CmiIsomallocFree(doomed);
+  } while (cur!=start);
 }
 
 /*Allocate a block from this blockList*/
 void *CmiIsomallocBlockListMalloc(CmiIsomallocBlockList *l,size_t nBytes)
 {
 }
 
 /*Allocate a block from this blockList*/
 void *CmiIsomallocBlockListMalloc(CmiIsomallocBlockList *l,size_t nBytes)
 {
-    CmiIsomallocBlockList *n; /*Newly created slot*/
-       n=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(CmiIsomallocBlockList)+nBytes);
-       /*Link the new block into the circular blocklist*/
-       n->prev=l;
-       n->next=l->next;
-       l->next->prev=n;
-       l->next=n;
-       return Slot_toUser(n);
+  CmiIsomallocBlockList *n; /*Newly created slot*/
+  n=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(CmiIsomallocBlockList)+nBytes);
+  /*Link the new block into the circular blocklist*/
+  n->prev=l;
+  n->next=l->next;
+  l->next->prev=n;
+  l->next=n;
+  return Slot_toUser(n);
 }
 
 /*Allocate a block from this blockList with alighment */
 void *CmiIsomallocBlockListMallocAlign(CmiIsomallocBlockList *l,size_t align,size_t nBytes)
 {
 }
 
 /*Allocate a block from this blockList with alighment */
 void *CmiIsomallocBlockListMallocAlign(CmiIsomallocBlockList *l,size_t align,size_t nBytes)
 {
-    CmiIsomallocBlockList *n; /*Newly created slot*/
-       n=(CmiIsomallocBlockList *)_isomallocAlign(align,nBytes,sizeof(CmiIsomallocBlockList));
-       /*Link the new block into the circular blocklist*/
-       n->prev=l;
-       n->next=l->next;
-       l->next->prev=n;
-       l->next=n;
-       return Slot_toUser(n);
+  CmiIsomallocBlockList *n; /*Newly created slot*/
+  n=(CmiIsomallocBlockList *)_isomallocAlign(align,nBytes,sizeof(CmiIsomallocBlockList));
+  /*Link the new block into the circular blocklist*/
+  n->prev=l;
+  n->next=l->next;
+  l->next->prev=n;
+  l->next=n;
+  return Slot_toUser(n);
 }
 
 /*Remove this block from its list and memory*/
 void CmiIsomallocBlockListFree(void *block)
 {
 }
 
 /*Remove this block from its list and memory*/
 void CmiIsomallocBlockListFree(void *block)
 {
-    CmiIsomallocBlockList *n=Slot_fmUser(block);
+  CmiIsomallocBlockList *n=Slot_fmUser(block);
 #if DOHEAPCHECK
 #if DOHEAPCHECK
-       if (n->prev->next!=n || n->next->prev!=n) 
-               CmiAbort("Heap corruption detected in isomalloc block list header!\n"
-                       "  Run with ++debug and look for writes to negative array indices");
+  if (n->prev->next!=n || n->next->prev!=n) 
+    CmiAbort("Heap corruption detected in isomalloc block list header!\n"
+        "  Run with ++debug and look for writes to negative array indices");
 #endif
 #endif
-       /*Link ourselves out of the blocklist*/
-       n->prev->next=n->next;
-       n->next->prev=n->prev;
-       CmiIsomallocFree(n);
+  /*Link ourselves out of the blocklist*/
+  n->prev->next=n->next;
+  n->next->prev=n->prev;
+  CmiIsomallocFree(n);
 }
 
 
 
 /* BIGSIM_OOC DEBUGGING */
 static void print_myslots(){
 }
 
 
 
 /* BIGSIM_OOC DEBUGGING */
 static void print_myslots(){
-    CmiPrintf("[%d] my slot set=%p\n", CmiMyPe(), CpvAccess(myss));
-    print_slots(CpvAccess(myss));
+  CmiPrintf("[%d] my slot set=%p\n", CmiMyPe(), CpvAccess(myss));
+  print_slots(CpvAccess(myss));
 }
 
 
 }