mirror of
https://github.com/versity/scoutfs.git
synced 2026-07-29 11:33:19 +00:00
Zach BrownandZach Brown
9375b9d3b7
Dirty items in a client transaction are stored in OS pages. When the transaction is committed each item is stored in its position in a dirty btree block in the client's existing log btree. Allocators are refilled between transaction commits so a given commit must have sufficient meta allocator space (avail blocks and unused freed entries) for all the btree blocks that are dirtied. The number of btree blocks that are written, thus the number of cow allocations and frees, depends on the number of blocks in the log btree and the distribution of dirty items amongst those blocks. In a typical load items will be near each other and many dirty items in smaller kernel pages will be stored in fewer larger btree blocks. But with the right circumstances, the ratio of dirty pages to dirty blocks can be much smaller. With a very large directory and random entry renames you can easily have 1 btree block dirtied for every page of dirty items. Our existing allocator meta allocator fill targets and the number of dirty item cache pages we allowed did not properly take this in to account. It was possible (and, it turned out, relatively easy to test for with a hgue directory and random renames) to run out of meta avail blocks while storing dirty items in dirtied btree blocks. This rebalances our targets and thresholds to make it more likely that we'll have enough allocator resources to commit dirty items. Instead of having an arbitrary limit on the number of dirty item cache pages, we require that a given number of dirty item cache pages have a given number of allocator blocks available. We require a decent number of avialable blocks for each dirty page, so we increase the server's target number of blocks to give the client so that it can still build large transactions. This code is conservative and should not be a problem in practice, but it's theoretically possible to build a log btree and set of dirty items that would dirty more blocks that this code assumes. We will probably revisit this as we add proper support for ENOSPC. Signed-off-by: Zach Brown <zab@versity.com>
136 lines
5.0 KiB
C
136 lines
5.0 KiB
C
#ifndef _SCOUTFS_ALLOC_H_
|
|
#define _SCOUTFS_ALLOC_H_
|
|
|
|
#include "ext.h"
|
|
|
|
/*
|
|
* These are implementation-specific metrics, they don't need to be
|
|
* consistent across implementations. They should probably be run-time
|
|
* knobs.
|
|
*/
|
|
|
|
/*
|
|
* The largest extent that we'll try to allocate with fallocate. We're
|
|
* trying not to completely consume a transactions data allocation all
|
|
* at once. This is only allocation granularity, repeated allocations
|
|
* can produce large contiguous extents.
|
|
*/
|
|
#define SCOUTFS_FALLOCATE_ALLOC_LIMIT \
|
|
(128ULL * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
|
|
|
|
/*
|
|
* The largest aligned region that we'll try to allocate at the end of
|
|
* the file as it's extended. This is also limited to the current file
|
|
* size so we can only waste at most twice the total file size when
|
|
* files are less than this. We try to keep this around the point of
|
|
* diminishing returns in streaming performance of common data devices
|
|
* to limit waste.
|
|
*/
|
|
#define SCOUTFS_DATA_EXTEND_PREALLOC_LIMIT \
|
|
(8ULL * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
|
|
|
|
/*
|
|
* Small data allocations are satisfied by cached extents stored in
|
|
* the run-time alloc struct to minimize item operations for small
|
|
* block allocations. Large allocations come directly from btree
|
|
* extent items, and this defines the threshold beetwen them.
|
|
*/
|
|
#define SCOUTFS_ALLOC_DATA_LG_THRESH \
|
|
(8ULL * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
|
|
|
|
/*
|
|
* Fill client alloc roots to the target when they fall below the lo
|
|
* threshold.
|
|
*
|
|
* We're giving the client the most available meta blocks we can so that
|
|
* it has the freedom to build large transactions before worrying that
|
|
* it might run out of meta allocs during commits.
|
|
*/
|
|
#define SCOUTFS_SERVER_META_FILL_TARGET \
|
|
SCOUTFS_ALLOC_LIST_MAX_BLOCKS
|
|
#define SCOUTFS_SERVER_META_FILL_LO \
|
|
(SCOUTFS_ALLOC_LIST_MAX_BLOCKS / 2)
|
|
#define SCOUTFS_SERVER_DATA_FILL_TARGET \
|
|
(4ULL * 1024 * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
|
|
#define SCOUTFS_SERVER_DATA_FILL_LO \
|
|
(1ULL * 1024 * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
|
|
|
|
/*
|
|
* Each of the server meta_alloc roots will try to keep a minimum amount
|
|
* of free blocks. The server will swap roots when its current avail
|
|
* falls below the threshold while the freed root is still above it. It
|
|
* must have room for all the largest allocation attempted in a
|
|
* transaction on the server.
|
|
*/
|
|
#define SCOUTFS_SERVER_META_ALLOC_MIN \
|
|
(SCOUTFS_SERVER_META_FILL_TARGET * 2)
|
|
|
|
/*
|
|
* A run-time use of a pair of persistent avail/freed roots as a
|
|
* metadata allocator. It has the machinery needed to lock and avoid
|
|
* recursion when dirtying the list blocks that are used during the
|
|
* transaction.
|
|
*/
|
|
struct scoutfs_alloc {
|
|
spinlock_t lock;
|
|
struct mutex mutex;
|
|
struct scoutfs_block *dirty_avail_bl;
|
|
struct scoutfs_block *dirty_freed_bl;
|
|
struct scoutfs_alloc_list_head avail;
|
|
struct scoutfs_alloc_list_head freed;
|
|
};
|
|
|
|
void scoutfs_alloc_init(struct scoutfs_alloc *alloc,
|
|
struct scoutfs_alloc_list_head *avail,
|
|
struct scoutfs_alloc_list_head *freed);
|
|
int scoutfs_alloc_prepare_commit(struct super_block *sb,
|
|
struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri);
|
|
|
|
int scoutfs_alloc_meta(struct super_block *sb, struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri, u64 *blkno);
|
|
int scoutfs_free_meta(struct super_block *sb, struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri, u64 blkno);
|
|
|
|
int scoutfs_alloc_data(struct super_block *sb, struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri,
|
|
struct scoutfs_alloc_root *root,
|
|
struct scoutfs_extent *cached, u64 count,
|
|
u64 *blkno_ret, u64 *count_ret);
|
|
int scoutfs_free_data(struct super_block *sb, struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri,
|
|
struct scoutfs_alloc_root *root, u64 blkno, u64 count);
|
|
|
|
int scoutfs_alloc_move(struct super_block *sb, struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri,
|
|
struct scoutfs_alloc_root *dst,
|
|
struct scoutfs_alloc_root *src, u64 total);
|
|
|
|
int scoutfs_alloc_fill_list(struct super_block *sb,
|
|
struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri,
|
|
struct scoutfs_alloc_list_head *lhead,
|
|
struct scoutfs_alloc_root *root,
|
|
u64 lo, u64 target);
|
|
int scoutfs_alloc_empty_list(struct super_block *sb,
|
|
struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri,
|
|
struct scoutfs_alloc_root *root,
|
|
struct scoutfs_alloc_list_head *lhead);
|
|
int scoutfs_alloc_splice_list(struct super_block *sb,
|
|
struct scoutfs_alloc *alloc,
|
|
struct scoutfs_block_writer *wri,
|
|
struct scoutfs_alloc_list_head *dst,
|
|
struct scoutfs_alloc_list_head *src);
|
|
|
|
bool scoutfs_alloc_meta_low(struct super_block *sb,
|
|
struct scoutfs_alloc *alloc, u32 nr);
|
|
|
|
typedef int (*scoutfs_alloc_foreach_cb_t)(struct super_block *sb, void *arg,
|
|
int owner, u64 id,
|
|
bool meta, bool avail, u64 blocks);
|
|
int scoutfs_alloc_foreach(struct super_block *sb,
|
|
scoutfs_alloc_foreach_cb_t cb, void *arg);
|
|
|
|
#endif
|