zbd: rename the accounting 'sectors with data' to 'valid data bytes'

The 'sectors with data' accounting was designed to have 'sector' as its
unit. Then related variables have the word 'sector' in their names. Also
related code comments use the words 'sector' or 'logical blocks'.
However, actually it was implemented to have 'byte' as unit. Rename
related variables and comments to indicate the byte unit. Also replace
the abbreviation swd to vdb.

Fixes: a7c2b6fc2959 ("Add support for resetting zones periodically")
Signed-off-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Reviewed-by: Niklas Cassel <niklas.cassel@wdc.com>
Signed-off-by: Vincent Fu <vincent.fu@samsung.com>

diff --git a/t/zbd/test-zbd-support b/t/zbd/test-zbd-support
index 4091d9ac95c89713397a61af65ffff88ddd72918..c32953c48bf56e81e7f10eaafb2d4a55ba09f427 100755 (executable)
--- a/t/zbd/test-zbd-support
+++ b/t/zbd/test-zbd-support
@@ -1110,8 +1110,8 @@ test51() {
        run_fio "${opts[@]}" >> "${logfile}.${test_number}" 2>&1 || return $?
 }
 
-# Verify that zone_reset_threshold only takes logical blocks from seq
-# zones into account, and logical blocks of conv zones are not counted.
+# Verify that zone_reset_threshold only accounts written bytes in seq
+# zones, and written data bytes of conv zones are not counted.
 test52() {
        local off io_size
 

diff --git a/zbd.c b/zbd.c
index b6cf2a93be86e7b630ea20b63df2475eb2304b71..455dad53113166dc45fb03a4e004f3cca5e02129 100644 (file)
--- a/zbd.c
+++ b/zbd.c
@@ -286,7 +286,7 @@ static int zbd_reset_zone(struct thread_data *td, struct fio_file *f,
        }
 
        pthread_mutex_lock(&f->zbd_info->mutex);
-       f->zbd_info->wp_sectors_with_data -= data_in_zone;
+       f->zbd_info->wp_valid_data_bytes -= data_in_zone;
        pthread_mutex_unlock(&f->zbd_info->mutex);
 
        z->wp = z->start;
@@ -1190,35 +1190,35 @@ static bool zbd_dec_and_reset_write_cnt(const struct thread_data *td,
        return write_cnt == 0;
 }
 
-static uint64_t zbd_set_swd(struct thread_data *td, const struct fio_file *f)
+static uint64_t zbd_set_vdb(struct thread_data *td, const struct fio_file *f)
 {
        struct fio_zone_info *zb, *ze, *z;
-       uint64_t wp_swd = 0;
+       uint64_t wp_vdb = 0;
 
        zb = zbd_get_zone(f, f->min_zone);
        ze = zbd_get_zone(f, f->max_zone);
        for (z = zb; z < ze; z++) {
                if (z->has_wp) {
                        zone_lock(td, f, z);
-                       wp_swd += z->wp - z->start;
+                       wp_vdb += z->wp - z->start;
                }
        }
 
        pthread_mutex_lock(&f->zbd_info->mutex);
-       f->zbd_info->wp_sectors_with_data = wp_swd;
+       f->zbd_info->wp_valid_data_bytes = wp_vdb;
        pthread_mutex_unlock(&f->zbd_info->mutex);
 
        for (z = zb; z < ze; z++)
                if (z->has_wp)
                        zone_unlock(z);
 
-       return wp_swd;
+       return wp_vdb;
 }
 
 void zbd_file_reset(struct thread_data *td, struct fio_file *f)
 {
        struct fio_zone_info *zb, *ze;
-       uint64_t swd;
+       uint64_t vdb;
        bool verify_data_left = false;
 
        if (!f->zbd_info || !td_write(td))
@@ -1226,10 +1226,10 @@ void zbd_file_reset(struct thread_data *td, struct fio_file *f)
 
        zb = zbd_get_zone(f, f->min_zone);
        ze = zbd_get_zone(f, f->max_zone);
-       swd = zbd_set_swd(td, f);
+       vdb = zbd_set_vdb(td, f);
 
-       dprint(FD_ZBD, "%s(%s): swd = %" PRIu64 "\n",
-              __func__, f->file_name, swd);
+       dprint(FD_ZBD, "%s(%s): valid data bytes = %" PRIu64 "\n",
+              __func__, f->file_name, vdb);
 
        /*
         * If data verification is enabled reset the affected zones before
@@ -1607,7 +1607,7 @@ static void zbd_queue_io(struct thread_data *td, struct io_u *io_u, int q,
                 */
                pthread_mutex_lock(&zbd_info->mutex);
                if (z->wp <= zone_end)
-                       zbd_info->wp_sectors_with_data += zone_end - z->wp;
+                       zbd_info->wp_valid_data_bytes += zone_end - z->wp;
                pthread_mutex_unlock(&zbd_info->mutex);
                z->wp = zone_end;
                break;
@@ -1960,7 +1960,8 @@ retry:
 
                /* Check whether the zone reset threshold has been exceeded */
                if (td->o.zrf.u.f) {
-                       if (zbdi->wp_sectors_with_data >= f->io_size * td->o.zrt.u.f &&
+                       if (zbdi->wp_valid_data_bytes >=
+                           f->io_size * td->o.zrt.u.f &&
                            zbd_dec_and_reset_write_cnt(td, f))
                                zb->reset_zone = 1;
                }

diff --git a/zbd.h b/zbd.h
index 9ab25c47e98bfd984b9021cfa75cba7c9538726b..20b2fe17ddffffbbff7ded8080022e545a4528e1 100644 (file)
--- a/zbd.h
+++ b/zbd.h
@@ -54,8 +54,7 @@ struct fio_zone_info {
  * @mutex: Protects the modifiable members in this structure (refcount and
  *             num_open_zones).
  * @zone_size: size of a single zone in bytes.
- * @wp_sectors_with_data: total size of data in zones with write pointers in
- *                        units of 512 bytes
+ * @wp_valid_data_bytes: total size of data in zones with write pointers
  * @zone_size_log2: log2 of the zone size in bytes if it is a power of 2 or 0
  *             if the zone size is not a power of 2.
  * @nr_zones: number of zones
@@ -75,7 +74,7 @@ struct zoned_block_device_info {
        uint32_t                max_open_zones;
        pthread_mutex_t         mutex;
        uint64_t                zone_size;
-       uint64_t                wp_sectors_with_data;
+       uint64_t                wp_valid_data_bytes;
        uint32_t                zone_size_log2;
        uint32_t                nr_zones;
        uint32_t                refcount;