Quick Search:

Context

Displaying 3 lines either side each change. None | Less | More | Full

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.1.2.1
  
1.1.2.2
  
Orange-Elaine-Distr-Dir-Branch:shuangy:20100729232348
  
dist-dir-utils.c
_>2121 /* calculate log2 of number */
 2222 static double my_log2(const double n)
 2323 {
<>24 -        return log(n) / log(2);
  24+        return log(n) / log(2.0);
2525 }
 2626 
 2727 /* calculate branch_level for a server from a bitmap */
 2828 static int dist_dir_calc_branch_level(
<>29 -                const PVFS_dist_dir_attr *dist_dir_attr, const PVFS_dist_dir_bitmap bitmap)
  29+                const PVFS_dist_dir_attr *dist_dir_attr, 
  30+                const PVFS_dist_dir_bitmap bitmap)
3031 {
 3132         int level = 0;
 3233         int server_no, num_servers;
 3334 
 3435         server_no = dist_dir_attr->server_no;
 3536         num_servers = dist_dir_attr->num_servers;
 3637 
<> 38+        /* meta handle copy (server_no = -1) shall not reach here */
3739         assert(server_no >= 0 && server_no < num_servers);
<> 40+        assert(bitmap != NULL);
3841 
 3942         if(!(TST_BIT(bitmap, server_no)))
<> 43+        {
4044                 return -1; /* not an active server */
<> 45+        }
4146 
 4247         /* get the number of bits above which all bits are zero */
 4348         while( server_no >> level )
<> 49+        {
4450                 level++;
<> 51+        }
4552 
 4653         /* until no splitting node is set */
 4754         while( TST_BIT(bitmap, server_no + (1l << level)) )
<> 55+        {
4856                 level++;
<> 57+        }
4958 
 5059         return level;
 5160 }
      
 !
 
…
5564  * ***************************/
 5665 
 5766 /* init dir state function, set all parameters
<>58 - * server_no <- 0..(num_servers-1)
  67+ * server_no <- -1..(num_servers-1)
5968  * pre_dsg_num_server: pre-set a number of servers, used for known large directory. default value can be 1.
 6069  */
 6170 
 6271 int PINT_init_dist_dir_state(
<>63 -                PVFS_dist_dir_attr *dist_dir_attr, PVFS_dist_dir_bitmap *bitmap_ptr,
 64 -                int num_servers, int server_no, int pre_dsg_num_server)
  72+                PVFS_dist_dir_attr *dist_dir_attr, 
  73+                PVFS_dist_dir_bitmap *bitmap_ptr,
  74+                const int num_servers, 
  75+                const int server_no, 
  76+                int pre_dsg_num_server)
6577 {
 6678         int i;
 6779 
 6880         assert(dist_dir_attr != NULL);
 6981 
<>70 -        /* 0 <= server_no < num_servers && 0 < pre_dsg_num_server <= num_servers */
 71 -        if( (num_servers < 1) ||
 72 -                (server_no < -1) || /* metadata handle has server_no = -1 */
 73 -                (server_no >= num_servers) ||
 74 -                (pre_dsg_num_server <= 0) ||
 75 -                (pre_dsg_num_server > num_servers) )
 76 -                return -1;
  82+        /* -1 <= server_no < num_servers && 0 < pre_dsg_num_server <= num_servers */
  83+        assert( (num_servers < 1) ||
  84+                        (server_no < -1) || /* metadata handle has server_no = -1 */
  85+                        (server_no >= num_servers));
7786 
<> 87+        if ((pre_dsg_num_server <= 0) ||
  88+                (pre_dsg_num_server > num_servers))
  89+        {
  90+                pre_dsg_num_server = num_servers;       
  91+        }
  92+
7893         dist_dir_attr->num_servers = num_servers;
 7994         dist_dir_attr->server_no = server_no;
<>80 -        dist_dir_attr->tree_height = (int)ceil(my_log2((double)num_servers)); /* tree_height start from 0 */
  95+        /* tree_height start from 0 */
  96+        dist_dir_attr->tree_height = (int)ceil(my_log2((double)num_servers)); 
8197 
 8298         /* increase bitmap_size if 2^tree_height > 32
 8399          * bitmap has at least 2^tree_height bits, that is, the number of leaves of a full tree. */
 84100         if( (1l << dist_dir_attr->tree_height) >
 85101                 (sizeof(PVFS_dist_dir_bitmap_basetype) * 8))
<> 102+        {
86103                 dist_dir_attr->bitmap_size = ((1l << dist_dir_attr->tree_height) >> 5);
<> 104+        }
87105         else
<> 106+        {
88107                 dist_dir_attr->bitmap_size = 1;
<> 108+        }
89109 
 90110         *bitmap_ptr = (PVFS_dist_dir_bitmap) malloc(
 91111                         dist_dir_attr->bitmap_size * sizeof(PVFS_dist_dir_bitmap_basetype));
 92112         if ((*bitmap_ptr) == NULL)
<> 113+        {
93114                 return -1;
<> 115+        }
94116 
 95117         memset((*bitmap_ptr), 0,
 96118                         dist_dir_attr->bitmap_size * sizeof(PVFS_dist_dir_bitmap_basetype));
 97119 
 98120         for(i = pre_dsg_num_server-1; i >= 0; i--)
<> 121+        {
99122                 SET_BIT((*bitmap_ptr), i);
<> 123+        }
100124 
<>101 -        dist_dir_attr->branch_level = dist_dir_calc_branch_level(dist_dir_attr, *bitmap_ptr);
  125+        if(server_no > -1) /* an dirdata server */
  126+        {
  127+                dist_dir_attr->branch_level = dist_dir_calc_branch_level(dist_dir_attr, *bitmap_ptr);
  128+        }
  129+        else /* a meta server */
  130+        {
  131+                dist_dir_attr->branch_level = -1;
  132+        }
102133 
 103134         /* set split size */
 104135         dist_dir_attr->split_size = PVFS_DIST_DIR_MAX_ENTRIES;
      
 !
 
…
112143  * hash can be any value, whose rightmost several bits will be examined.
 113144  */
 114145 int PINT_find_dist_dir_bucket(
<>115 -                PVFS_dist_dir_hash_type hash, PVFS_dist_dir_attr *dist_dir_attr,
 116 -                PVFS_dist_dir_bitmap bitmap)
  146+                const PVFS_dist_dir_hash_type hash, 
  147+                const PVFS_dist_dir_attr *const dist_dir_attr,
  148+                const PVFS_dist_dir_bitmap bitmap)
117149 {
 118150         PVFS_dist_dir_hash_type node_val;
 119151         int level;
 120152 
 121153         assert(dist_dir_attr != NULL);
<> 154+        assert(bitmap != NULL);
122155 
 123156         level = dist_dir_attr->tree_height;
 124157 
 125158         if(level < 0)
<> 159+        {
126160                 return -1;
<> 161+        }
127162 
 128163         for( node_val = hash & ((1l << level) - 1); /* use the rightmost 'tree_height' bits */
 129164                  (level >= 0) && !(TST_BIT(bitmap, node_val)); /* test if node_val bit is set */
      
 !
 
…
137172  * this code return the index of the new node when a bucket is to be split
 138173  */
 139174 int PINT_find_dist_dir_split_node(
<>140 -                PVFS_dist_dir_attr *dist_dir_attr, PVFS_dist_dir_bitmap bitmap)
  175+                const PVFS_dist_dir_attr *const dist_dir_attr, 
  176+                const PVFS_dist_dir_bitmap bitmap)
141177 {
 142178         int new_node_val;
<> 179+        int branch_level;
143180 
<>144 -        assert(dist_dir_attr != NULL);
  181+        assert((dist_dir_attr != NULL) && 
  182+                   (dist_dir_attr->server_no > -1) &&
  183+                   (bitmap != NULL));
145184 
<> 185+        branch_level = dist_dir_attr->branch_level;
  186+
  187+        /* meta server or inactive dirdata server should not come here */
  188+        assert(branch_level > -1);
  189+
146190         /* if it reaches the maximum tree height */
<>147 -        if (dist_dir_attr->branch_level >= dist_dir_attr->tree_height)
  191+        if (branch_level >= dist_dir_attr->tree_height)
  192+        {
148193                 return -1;
<> 194+        }
149195 
 150196         /* calculate new node value */
<>151 -        new_node_val = dist_dir_attr->server_no + (1l << dist_dir_attr->branch_level);
  197+        new_node_val = dist_dir_attr->server_no 
  198+                                + (1l << branch_level);
152199         if(new_node_val >= dist_dir_attr->num_servers)
<> 200+        {
153201                 return -1;
<> 202+        }
154203 
<> 204+        /* new node must be unset, otherwise branch_level is messed up */
  205+        assert(!TST_BIT(bitmap, new_node_val));
  206+
155207         return new_node_val;
 156208 }
 157209 
 158210 /*
 159211  * update current bitmap tree and re-calculate branch_level
 160212  */
 161213 int PINT_update_dist_dir_bitmap_from_bitmap(
<>162 -                PVFS_dist_dir_attr *to_dir_attr, PVFS_dist_dir_bitmap to_dir_bitmap,
 163 -                const PVFS_dist_dir_attr *from_dir_attr, const PVFS_dist_dir_bitmap from_dir_bitmap)
  214+                PVFS_dist_dir_attr *to_dir_attr, 
  215+                PVFS_dist_dir_bitmap to_dir_bitmap,
  216+                const PVFS_dist_dir_attr *from_dir_attr, 
  217+                const PVFS_dist_dir_bitmap from_dir_bitmap)
164218 {
 165219         int i;
 166220 
 167221         assert((to_dir_attr != NULL) && (from_dir_attr != NULL));
<> 222+        assert((to_dir_bitmap != NULL) && (from_dir_bitmap != NULL));
168223 
 169224         if( (to_dir_attr->num_servers != from_dir_attr->num_servers) ||
 170225                 (to_dir_attr->server_no == from_dir_attr->server_no))
<> 226+        {
171227                 return -1; /* not in the same tree or update itself */
<> 228+        }
172229 
 173230         /* bitmap is with a type of (uint32_t *)
 174231          */
 175232         for(i = to_dir_attr->bitmap_size - 1;
<>176 -                        i >= 0; i--) {
  233+                i >= 0; i--) 
  234+        {
177235                 to_dir_bitmap[i] |= from_dir_bitmap[i];
 178236         }
 179237 
 180238         /* update branch level */
<> 239+        if(to_dir_attr->server_no > -1) /* dirdata server */
  240+        {
181241         to_dir_attr->branch_level = dist_dir_calc_branch_level(to_dir_attr, to_dir_bitmap);
<> 242+        }
<_182243 
 183244         /* anything else to update? */
 184245