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

CHAPTER 6. MICROBENCHMARKS – OTHER FUNDAMENTAL OPERATIONS 57
avg # cycles per processor
4e+09
3e+09
2e+09
1e+09
0e+00
2 4 6 8 10 12
# processors
Unoptimized 200 pool
Optimized
Figure 6.10: Lookup – all optimizations.
avg # cycles per processor
5e+07
4e+07
3e+07
2e+07
1e+07
0e+00
2 4 6 8 10 12
# processors
Optimized
Figure 6.11: Lookup – all optimizations, magnified.
3. Padded all other critical data structures in the ORS and block cache systems, such as locks and waiting
I/O data structures (shown in Figure 3.4 and Figure 3.5).
4. Modified hash functions. (ORS and block cache)
5. Increased size of hash tables. (ORS and block cache)
6. Increased initial pool of block cache entries from 20 to 200.
7. Elimination of the block cache free list.
8. Use of fine grain locks in the block cache.
For simplicity, the K42 padding facilities were used rather than manually padding and aligning the data
structures. The results, shown in Figure 6.10, indicate good scalability. A magnification of the graph,
shown in Figure 6.11, indicates that scalability was good but not ideal. The 8 processor results exhibited
the same anomaly as described in Section 5.5.7, resulting in the lower error bar in the graph.
The optimizations that applied to the read test workload were effective on the file creation and file lookup
workloads. The optimizations of padding, modifying the hash functions, increasing the size of hash tables,
eliminating the global free list, and using fine grain locks improved performance because the interactions
with the cache systems are based on the same basic operations. These operations include hashing, hash list
traversal, cache entry access and modification, dirty list enqueuing, and cache entry freeing.
6.3.3 Summary
Problems with the block cache entry allocation algorithm were evident with this simple microbenchmark
workload. Increasing the size of the initial pool of block cache entries helped to improve scalability. For
instance, on 12 processors, threads executed in approximately half the time as the unoptimized version.
The optimizations implemented from the read file experiments were applied to this workload and dramat-
ically improved scalability. Performance trends show that thread execution times appear to stabilize from
8 processors onwards.