weight selector

Signed-off-by: Paul Dagnelie <[email protected]>

Author: pcd1193182

include/os/freebsd/spl/sys/mod.h

@@ -77,6 +77,9 @@
 #define	param_set_active_allocator_args(var) \
     CTLTYPE_STRING, NULL, 0, param_set_active_allocator, "A"
 
+#define	param_set_active_weightfunc_args(var) \
+    CTLTYPE_STRING, NULL, 0, param_set_active_weightfunc, "A"
+
 #define	param_set_deadman_synctime_args(var) \
     CTLTYPE_U64, NULL, 0, param_set_deadman_synctime, "QU"
 

include/sys/metaslab.h

@@ -44,9 +44,13 @@ typedef struct metaslab_ops {
 	uint64_t (*msop_alloc)(metaslab_t *, uint64_t, uint64_t, uint64_t *);
 } metaslab_ops_t;
 
-
 extern const metaslab_ops_t zfs_metaslab_ops;
 
+typedef struct metaslab_wfs {
+	const char *mswf_name;
+	uint64_t (*mswf_func)(metaslab_t *);
+} metaslab_wfs_t;
+
 int metaslab_init(metaslab_group_t *, uint64_t, uint64_t, uint64_t,
     metaslab_t **);
 void metaslab_fini(metaslab_t *);
@@ -103,7 +107,7 @@ void metaslab_trace_init(zio_alloc_list_t *);
 void metaslab_trace_fini(zio_alloc_list_t *);
 
 metaslab_class_t *metaslab_class_create(spa_t *, const char *,
-    const metaslab_ops_t *, boolean_t);
+    const metaslab_ops_t *, const metaslab_wfs_t *, boolean_t);
 void metaslab_class_destroy(metaslab_class_t *);
 void metaslab_class_validate(metaslab_class_t *);
 void metaslab_class_balance(metaslab_class_t *mc, boolean_t onsync);

include/sys/metaslab_impl.h

@@ -203,6 +203,7 @@ struct metaslab_class {
 	spa_t			*mc_spa;
 	const char		*mc_name;
 	const metaslab_ops_t	*mc_ops;
+	const metaslab_wfs_t	*mc_wfs;
 
 	/*
 	 * Track the number of metaslab groups that have been initialized

include/sys/spa.h

@@ -1124,6 +1124,8 @@ extern uint64_t spa_dirty_data(spa_t *spa);
 extern spa_autotrim_t spa_get_autotrim(spa_t *spa);
 extern int spa_get_allocator(spa_t *spa);
 extern void spa_set_allocator(spa_t *spa, const char *allocator);
+extern int spa_get_weightfunc(spa_t *spa);
+extern void spa_set_weightfunc(spa_t *spa, const char *weightfunc);
 
 /* Miscellaneous support routines */
 extern void spa_load_failed(spa_t *spa, const char *fmt, ...)
@@ -1282,6 +1284,7 @@ int param_set_deadman_synctime(ZFS_MODULE_PARAM_ARGS);
 int param_set_slop_shift(ZFS_MODULE_PARAM_ARGS);
 int param_set_deadman_failmode(ZFS_MODULE_PARAM_ARGS);
 int param_set_active_allocator(ZFS_MODULE_PARAM_ARGS);
+int param_set_active_weightfunc(ZFS_MODULE_PARAM_ARGS);
 
 #ifdef ZFS_DEBUG
 #define	dprintf_bp(bp, fmt, ...) do {				\

include/sys/spa_impl.h

@@ -275,6 +275,7 @@ struct spa {
 	spa_allocs_use_t *spa_allocs_use;
 	int		spa_alloc_count;
 	int		spa_active_allocator;	/* selectable allocator */
+	int		spa_active_weightfunc;	/* selectable weight function */
 
 	/* per-allocator sync thread taskqs */
 	taskq_t		*spa_sync_tq;
@@ -501,7 +502,9 @@ extern void spa_set_deadman_synctime(hrtime_t ns);
 extern void spa_set_deadman_ziotime(hrtime_t ns);
 extern const char *spa_history_zone(void);
 extern const char *zfs_active_allocator;
+extern const char *zfs_active_weightfunc;
 extern int param_set_active_allocator_common(const char *val);
+extern int param_set_active_weightfunc_common(const char *val);
 
 #ifdef	__cplusplus
 }

man/man4/zfs.4

@@ -728,6 +728,25 @@ depends on kernel configuration.
 This is the minimum allocation size that will use scatter (page-based) ABDs.
 Smaller allocations will use linear ABDs.
 .
+.It Sy zfs_active_weightfunc Ns = Ns Sy auto Pq string
+Selects the metaslab weighting function to use.
+The weighting function can be one of auto, space, space_v2, and segment.
+This determines what weighting algorithm will be used to sort metaslabs for
+selection during the allocation process.
+The space_v2 and segment algorithms require the spacemap histogram feature to be
+enabled, and will fall back to the space algorithm if that feature is not
+enabled on the pool.
+.Pp
+The space algorithm combines the total free space in the metaslab with the
+fragmentation metric to balance toward metaslabs with more contiguous free
+space.
+The segment algorithm uses the spacemap histograms to calculate the weight from
+the largest free segment size, bucketed to powers of two, and the number of
+segments in that bucket.
+The space_v2 algorithm considers not only the largest free segment bucket, but
+the smaller ones as well, providing a higher weight to larger contiguous chunks.
+Auto provides the recommended algorithm (currently space_v2).
+.
 .It Sy zfs_arc_dnode_limit Ns = Ns Sy 0 Ns B Pq u64
 When the number of bytes consumed by dnodes in the ARC exceeds this number of
 bytes, try to unpin some of it in response to demand for non-metadata.

module/os/freebsd/zfs/sysctl_os.c

@@ -273,6 +273,24 @@ param_set_active_allocator(SYSCTL_HANDLER_ARGS)
 	return (param_set_active_allocator_common(buf));
 }
 
+int
+param_set_active_weightfunc(SYSCTL_HANDLER_ARGS)
+{
+	char buf[16];
+	int rc;
+
+	if (req->newptr == NULL)
+		strlcpy(buf, zfs_active_weightfunc, sizeof (buf));
+
+	rc = sysctl_handle_string(oidp, buf, sizeof (buf), req);
+	if (rc || req->newptr == NULL)
+		return (rc);
+	if (strcmp(buf, zfs_active_weightfunc) == 0)
+		return (0);
+
+	return (param_set_active_weightfunc_common(buf));
+}
+
 /*
  * In pools where the log space map feature is not enabled we touch
  * multiple metaslabs (and their respective space maps) with each

module/os/linux/zfs/spa_misc_os.c

@@ -116,6 +116,18 @@ param_set_active_allocator(const char *val, zfs_kernel_param_t *kp)
 	return (error);
 }
 
+int
+param_set_active_weightfunc(const char *val, zfs_kernel_param_t *kp)
+{
+	int error;
+
+	error = -param_set_active_weightfunc_common(val);
+	if (error == 0)
+		error = param_set_charp(val, kp);
+
+	return (error);
+}
+
 const char *
 spa_history_zone(void)
 {

module/zfs/metaslab.c

@@ -253,21 +253,6 @@ static int metaslab_perf_bias = 1;
  */
 static const boolean_t zfs_remap_blkptr_enable = B_TRUE;
 
-/*
- * Enable/disable segment-based metaslab selection.
- */
-static int zfs_metaslab_segment_weight_enabled = B_TRUE;
-
-/*
- * Enable/disable the new space-based metaslab selection algorithm.
- *
- * The new space-based algorithm attempts to take into account not only the
- * largest free segment, as the segment-based weight does, but other segments
- * that are almost as large. This can improve metaslab selection and reduce the
- * number of metaslab loads needed to satisfy a given set of allocations.
- */
-static int zfs_metaslab_space_weight_v2_enabled = B_TRUE;
-
 /*
  * When using segment-based metaslab selection, we will continue
  * allocating from the active metaslab until we have exhausted
@@ -433,7 +418,7 @@ metaslab_stat_fini(void)
  */
 metaslab_class_t *
 metaslab_class_create(spa_t *spa, const char *name,
-    const metaslab_ops_t *ops, boolean_t is_log)
+    const metaslab_ops_t *ops, const metaslab_wfs_t *wfs, boolean_t is_log)
 {
 	metaslab_class_t *mc;
 
@@ -443,6 +428,7 @@ metaslab_class_create(spa_t *spa, const char *name,
 	mc->mc_spa = spa;
 	mc->mc_name = name;
 	mc->mc_ops = ops;
+	mc->mc_wfs = wfs;
 	mc->mc_is_log = is_log;
 	mc->mc_alloc_io_size = SPA_OLD_MAXBLOCKSIZE;
 	mc->mc_alloc_max = UINT64_MAX;
@@ -3082,6 +3068,79 @@ metaslab_fini(metaslab_t *msp)
 	kmem_free(msp, sizeof (metaslab_t));
 }
 
+static uint64_t metaslab_space_weight(metaslab_t *msp);
+static uint64_t metaslab_segment_weight(metaslab_t *msp);
+static uint64_t metaslab_space_weight_v2(metaslab_t *msp);
+metaslab_wfs_t *metaslab_weightfunc(spa_t *spa);
+
+static metaslab_wfs_t metaslab_weightfuncs[] = {
+	{ "auto", metaslab_space_weight_v2 },
+	{ "space", metaslab_space_weight },
+	{ "space_v2", metaslab_space_weight_v2 },
+	{ "segment", metaslab_segment_weight },
+};
+
+static int
+spa_find_weightfunc_byname(const char *val)
+{
+	int a = ARRAY_SIZE(metaslab_weightfuncs) - 1;
+	for (; a >= 0; a--) {
+		if (strcmp(val, metaslab_weightfuncs[a].mswf_name) == 0)
+			return (a);
+	}
+	return (-1);
+}
+
+void
+spa_set_weightfunc(spa_t *spa, const char *weightfunc)
+{
+	int a = spa_find_weightfunc_byname(weightfunc);
+	if (a < 0) a = 0;
+	if (a != 1 && !spa_feature_is_enabled(spa,
+	    SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
+		zfs_dbgmsg("warning: weight function %s will not be used for "
+		    "pool %s since space map histograms are not enabled",
+		    weightfunc, spa_name(spa));
+	}
+	spa->spa_active_weightfunc = a;
+	zfs_dbgmsg("spa weight function: %s",
+	    metaslab_weightfuncs[a].mswf_name);
+}
+
+int
+spa_get_weightfunc(spa_t *spa)
+{
+	return (spa->spa_active_weightfunc);
+}
+
+#if defined(_KERNEL)
+int
+param_set_active_weightfunc_common(const char *val)
+{
+	char *p;
+
+	if (val == NULL)
+		return (SET_ERROR(EINVAL));
+
+	if ((p = strchr(val, '\n')) != NULL)
+		*p = '\0';
+
+	int a = spa_find_weightfunc_byname(val);
+	if (a < 0)
+		return (SET_ERROR(EINVAL));
+
+	zfs_active_weightfunc = metaslab_weightfuncs[a].mswf_name;
+	return (0);
+}
+#endif
+
+metaslab_wfs_t *
+metaslab_weightfunc(spa_t *spa)
+{
+	int weightfunc = spa_get_weightfunc(spa);
+	return (&metaslab_weightfuncs[weightfunc]);
+}
+
 /*
  * Return the weight of the specified metaslab, according to the new space-based
  * weighting algorithm. The metaslab must be loaded. This function can
@@ -3156,7 +3215,7 @@ metaslab_space_weight_from_spacemap(metaslab_t *msp)
 		if (segments == 0)
 			continue;
 		if (weight == 0)
-                	weight = i + sm->sm_shift;
+			weight = i + sm->sm_shift;
 		// Prevent overflow using log_2 math
 		if (seg_shift + highbit64(segments) > METASLAB_WEIGHT_MAX_IDX)
 			return (METASLAB_WEIGHT_MAX);
@@ -3186,8 +3245,16 @@ static uint64_t
 metaslab_space_weight_v2(metaslab_t *msp)
 {
 	metaslab_group_t *mg = msp->ms_group;
+	spa_t *spa = mg->mg_vd->vdev_spa;
 	uint64_t weight = 0;
 	uint8_t shift = mg->mg_vd->vdev_ashift;
+
+	if (!spa_feature_is_enabled(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM) ||
+	    (msp->ms_sm != NULL && msp->ms_sm->sm_dbuf->db_size !=
+	    sizeof (space_map_phys_t))) {
+		return (metaslab_space_weight(msp));
+	}
+
 	if (metaslab_allocated_space(msp) == 0) {
 		int idx = highbit64(msp->ms_size) - shift - 1 + 3;
 		weight = 1ULL << MIN(METASLAB_WEIGHT_MAX_IDX, 2 * idx);
@@ -3365,18 +3432,10 @@ metaslab_space_weight(metaslab_t *msp)
 {
 	metaslab_group_t *mg = msp->ms_group;
 	vdev_t *vd = mg->mg_vd;
-	spa_t *spa = vd->vdev_spa;
 	uint64_t weight, space;
 
 	ASSERT(MUTEX_HELD(&msp->ms_lock));
 
-	if (zfs_metaslab_space_weight_v2_enabled &&
-	    spa_feature_is_enabled(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM) &&
-	    (msp->ms_sm == NULL || msp->ms_sm->sm_dbuf->db_size ==
-	    sizeof (space_map_phys_t))) {
-		return (metaslab_space_weight_v2(msp));
-	}
-
 	/*
 	 * The baseline weight is the metaslab's free space.
 	 */
@@ -3532,11 +3591,18 @@ static uint64_t
 metaslab_segment_weight(metaslab_t *msp)
 {
 	metaslab_group_t *mg = msp->ms_group;
+	spa_t *spa = mg->mg_vd->vdev_spa;
 	uint64_t weight = 0;
 	uint8_t shift = mg->mg_vd->vdev_ashift;
 
 	ASSERT(MUTEX_HELD(&msp->ms_lock));
 
+	if (!spa_feature_is_enabled(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM) ||
+	    (msp->ms_sm != NULL && msp->ms_sm->sm_dbuf->db_size !=
+	    sizeof (space_map_phys_t))) {
+		return (metaslab_space_weight(msp));
+	}
+
 	/*
 	 * The metaslab is completely free.
 	 */
@@ -3641,8 +3707,6 @@ metaslab_should_allocate(metaslab_t *msp, uint64_t asize, boolean_t try_hard)
 static uint64_t
 metaslab_weight(metaslab_t *msp, boolean_t nodirty)
 {
-	vdev_t *vd = msp->ms_group->mg_vd;
-	spa_t *spa = vd->vdev_spa;
 	uint64_t weight;
 
 	ASSERT(MUTEX_HELD(&msp->ms_lock));
@@ -3666,17 +3730,7 @@ metaslab_weight(metaslab_t *msp, boolean_t nodirty)
 		    metaslab_largest_unflushed_free(msp));
 	}
 
-	/*
-	 * Segment-based weighting requires space map histogram support.
-	 */
-	if (zfs_metaslab_segment_weight_enabled &&
-	    spa_feature_is_enabled(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM) &&
-	    (msp->ms_sm == NULL || msp->ms_sm->sm_dbuf->db_size ==
-	    sizeof (space_map_phys_t))) {
-		weight = metaslab_segment_weight(msp);
-	} else {
-		weight = metaslab_space_weight(msp);
-	}
+	weight = msp->ms_group->mg_class->mc_wfs->mswf_func(msp);
 	return (weight);
 }
 
@@ -6566,12 +6620,6 @@ ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, bias_enabled, INT, ZMOD_RW,
 ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, perf_bias, INT, ZMOD_RW,
 	"Enable performance-based metaslab group biasing");
 
-ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, segment_weight_enabled, INT,
-	ZMOD_RW, "Enable segment-based metaslab selection");
-
-ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, space_weight_v2_enabled, INT,
-	ZMOD_RW, "Enable new space-based metaslab selection");
-
 ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, switch_threshold, INT, ZMOD_RW,
 	"Segment-based metaslab selection maximum buckets before switching");
 
@@ -6602,3 +6650,7 @@ ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, find_max_tries, UINT, ZMOD_RW,
 ZFS_MODULE_PARAM_CALL(zfs, zfs_, active_allocator,
 	param_set_active_allocator, param_get_charp, ZMOD_RW,
 	"SPA active allocator");
+
+ZFS_MODULE_PARAM_CALL(zfs, zfs_, active_weightfunc,
+	param_set_active_weightfunc, param_get_charp, ZMOD_RW,
+	"SPA active weight function");