Performance Analysis and Optimization of the Hurricane File System ...

CHAPTER 5. MICROBENCHMARKS – READ OPERATION 49
is implemented as an array, containing a fixed number of elements. If all elements of an array are occupied
when a new element is needed from the array, a victim element must be picked for recycling and reuse.
A free list is associated with each hash list to track free elements in the hash list. Rather than having a
lock for each free list and hash list, each pair of hash and free list is protected by one lock. Array indices
rather than memory pointers are used because elements do not migrate between hash lists or free lists. This
lack of migration combined with the fixed and equal number of elements on each hash list partially solves
the balancing issue, since the maximum potential length of a free list is equal to the maximum size of an
array. Free lists cannot become too unbalanced, only slightly unbalanced. An important parameter value
to determine is the size of the hash list arrays, since the number of elements is fixed. The static nature of
the SSAC organization makes this solution fairly rigid and limits the ability to handle load imbalances. For
example, heavily used hash lists cannot exploit free elements located in hash lists that are mostly idle.
Rather than implementing a particular solution and radically modifying the block cache system once
more, we decided to focus our efforts on exploring the remaining scalability problem shown in Figure 5.28.
Implementing a free list solution is a subject of future work.
5.5.8 Global Lock, Larger Rehashed Table, No Free List
This experiment examines the relevance of the global lock once the free list bottleneck is eliminated. The
configuration was the same as in Section 5.5.7 except that the single global lock was used rather than the
fine grain locks in the block cache system. The results are shown in Figure 5.30. Performance was similar
to the results in Section 5.5.3 (where a modified hash function and larger hash table were used) except that
performance was better on 4 processors. Since the free list bottleneck was eliminated in the block cache
system, the next performance encountered was the single global lock. The global lock was effective for up
to 4 processors but became the critical bottle bottleneck beyond this point despite the distributed usage of
64 hash lists. Fine grain locks were indeed required to eliminate the bottleneck.
There is a potential concern with the number of locks that must be acquired in the fine grain lock
implementation. The overhead of acquiring locks, even if they are completely uncontended, may accumulate
to a significant amount of time. The results from this experiment demonstrate that the benefits of fine grain
locks in the file system far out-weigh the costs of acquiring approximately 3 additional locks.
5.5.9 All Optimizations Combined
All optimizations were applied in this experiment to determine whether ideal performance and scalability
could be achieved. These optimizations included the following.
1. Padded ORS hash list headers.