tx_regmap.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2013-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once
#ifndef __MOTR_BE_TX_REGMAP_H__
#define __MOTR_BE_TX_REGMAP_H__

#include "lib/time.h"           /* m0_time_t */

#include "be/seg.h"             /* m0_be_reg */
#include "be/tx_credit.h"       /* m0_be_tx_credit */

struct m0_ext;
struct m0_be_op;
struct m0_be_io;

struct m0_be_reg_d {
        struct m0_be_reg rd_reg;
        void            *rd_buf;
        unsigned long    rd_gen_idx;
};

#define M0_BE_REG_D(reg, buf) (struct m0_be_reg_d) \
                { .rd_reg = (reg), .rd_buf = (buf) }
#define M0_BE_REG_D_CREDIT(rd) M0_BE_TX_CREDIT(1, (rd)->rd_reg.br_size)

struct m0_be_reg_d_tree {
        size_t              brt_size;
        size_t              brt_size_max;
        struct m0_be_reg_d *brt_r;
};

struct m0_be_regmap_ops {
        void (*rmo_add)(void *data, struct m0_be_reg_d *rd);
        void (*rmo_del)(void *data, const struct m0_be_reg_d *rd);
        void (*rmo_cpy)(void *data, const struct m0_be_reg_d *super,
                        const struct m0_be_reg_d *rd);
        void (*rmo_cut)(void *data, struct m0_be_reg_d *rd,
                        m0_bcount_t cut_at_start, m0_bcount_t cut_at_end);
        void (*rmo_split)(void               *data,
                          struct m0_be_reg_d *rd,
                          struct m0_be_reg_d *rd_new);
};

struct m0_be_regmap {
        struct m0_be_reg_d_tree        br_rdt;
        const struct m0_be_regmap_ops *br_ops;
        void                          *br_ops_data;
        bool                           br_split_on_absorb;
};

M0_INTERNAL bool m0_be_reg_d__invariant(const struct m0_be_reg_d *rd);
M0_INTERNAL bool m0_be_reg_d_is_in(const struct m0_be_reg_d *rd, void *ptr);

M0_INTERNAL int m0_be_rdt_init(struct m0_be_reg_d_tree *rdt, size_t size_max);
M0_INTERNAL void m0_be_rdt_fini(struct m0_be_reg_d_tree *rdt);
M0_INTERNAL bool m0_be_rdt__invariant(const struct m0_be_reg_d_tree *rdt);
M0_INTERNAL size_t m0_be_rdt_size(const struct m0_be_reg_d_tree *rdt);

M0_INTERNAL struct m0_be_reg_d *
m0_be_rdt_find(const struct m0_be_reg_d_tree *rdt, void *addr);
M0_INTERNAL struct m0_be_reg_d *
m0_be_rdt_next(const struct m0_be_reg_d_tree *rdt, struct m0_be_reg_d *prev);

M0_INTERNAL void m0_be_rdt_ins(struct m0_be_reg_d_tree  *rdt,
                               const struct m0_be_reg_d *rd);
M0_INTERNAL struct m0_be_reg_d *m0_be_rdt_del(struct m0_be_reg_d_tree  *rdt,
                                              const struct m0_be_reg_d *rd);

M0_INTERNAL void m0_be_rdt_reset(struct m0_be_reg_d_tree *rdt);

/*
 * Initialises regmap.
 *
 * @param split_on_absorb controls regmap behavior when new region is added to
 *                        regmap and an existing region in regmap completely
 *                        contains the new.
 *
 * If split_on_absorb is true then existing region is splitted into 2 regions
 * (if it is possible), and new region is inserted between them.
 * If split_on_absorb is false then new region is "copied" into the old one,
 * so no new regions are added to the reg_d tree.
 */
M0_INTERNAL int
m0_be_regmap_init(struct m0_be_regmap           *rm,
                  const struct m0_be_regmap_ops *ops,
                  void                          *ops_data,
                  size_t                         size_max,
                  bool                           split_on_absorb);
M0_INTERNAL void m0_be_regmap_fini(struct m0_be_regmap *rm);
M0_INTERNAL bool m0_be_regmap__invariant(const struct m0_be_regmap *rm);

/* XXX add const */
M0_INTERNAL void m0_be_regmap_add(struct m0_be_regmap *rm,
                                  struct m0_be_reg_d  *rd);
M0_INTERNAL void m0_be_regmap_del(struct m0_be_regmap      *rm,
                                  const struct m0_be_reg_d *rd);

M0_INTERNAL struct m0_be_reg_d *m0_be_regmap_first(struct m0_be_regmap *rm);
M0_INTERNAL struct m0_be_reg_d *m0_be_regmap_next(struct m0_be_regmap *rm,
                                                  struct m0_be_reg_d  *prev);
M0_INTERNAL size_t m0_be_regmap_size(const struct m0_be_regmap *rm);

M0_INTERNAL void m0_be_regmap_reset(struct m0_be_regmap *rm);

enum m0_be_reg_area_type {
        M0_BE_REG_AREA_DATA_COPY,
        M0_BE_REG_AREA_DATA_NOCOPY,
};

struct m0_be_reg_area {
        struct m0_be_regmap       bra_map;
        enum m0_be_reg_area_type  bra_type;
        // bool                   bra_data_copy;
        char                     *bra_area;
        m0_bcount_t               bra_area_used;
        struct m0_be_tx_credit    bra_prepared;
        struct m0_be_tx_credit    bra_captured;
};

M0_INTERNAL int m0_be_reg_area_init(struct m0_be_reg_area        *ra,
                                    const struct m0_be_tx_credit *prepared,
                                    enum m0_be_reg_area_type      type);
M0_INTERNAL void m0_be_reg_area_fini(struct m0_be_reg_area *ra);
M0_INTERNAL bool m0_be_reg_area__invariant(const struct m0_be_reg_area *ra);

M0_INTERNAL void m0_be_reg_area_used(struct m0_be_reg_area  *ra,
                                     struct m0_be_tx_credit *used);
M0_INTERNAL void m0_be_reg_area_prepared(struct m0_be_reg_area  *ra,
                                         struct m0_be_tx_credit *prepared);
M0_INTERNAL void m0_be_reg_area_captured(struct m0_be_reg_area  *ra,
                                         struct m0_be_tx_credit *captured);

M0_INTERNAL void m0_be_reg_area_capture(struct m0_be_reg_area *ra,
                                        struct m0_be_reg_d    *rd);
M0_INTERNAL void m0_be_reg_area_uncapture(struct m0_be_reg_area    *ra,
                                          const struct m0_be_reg_d *rd);

M0_INTERNAL void m0_be_reg_area_merge_in(struct m0_be_reg_area *ra,
                                         struct m0_be_reg_area *src);

M0_INTERNAL void m0_be_reg_area_reset(struct m0_be_reg_area *ra);

/*
 * Try to reduce used space of reg_area by removing unused space
 * between captured regions and/or regions reordering/merging inside reg_area.
 *
 * @note XXX not implemented yet.
 */
M0_INTERNAL void m0_be_reg_area_optimize(struct m0_be_reg_area *ra);

M0_INTERNAL struct m0_be_reg_d *m0_be_reg_area_first(struct m0_be_reg_area *ra);
M0_INTERNAL struct m0_be_reg_d *
m0_be_reg_area_next(struct m0_be_reg_area *ra, struct m0_be_reg_d *prev);

#define M0_BE_REG_AREA_FORALL(ra, rd)                   \
        for ((rd) = m0_be_reg_area_first(ra);           \
             (rd) != NULL;                              \
             (rd) = m0_be_reg_area_next((ra), (rd)))

/*
 * Merger merges multiple reg_areas (sources) into one (destination) by the
 * following rules:
 * - if a region is in some source reg_area then the region is in the
 *   destination reg_area;
 * - destination reg_area contains regions with largest generation index among
 *   all source reg_areas.
 */
struct m0_be_reg_area_merger {
        int                     brm_reg_area_nr_max;
        int                     brm_reg_area_nr;
        struct m0_be_reg_area **brm_reg_areas;
        struct m0_be_reg_d    **brm_pos;
};

M0_INTERNAL int
m0_be_reg_area_merger_init(struct m0_be_reg_area_merger *brm,
                           int                           reg_area_nr_max);
M0_INTERNAL void m0_be_reg_area_merger_fini(struct m0_be_reg_area_merger *brm);
M0_INTERNAL void m0_be_reg_area_merger_reset(struct m0_be_reg_area_merger *brm);

M0_INTERNAL void m0_be_reg_area_merger_add(struct m0_be_reg_area_merger *brm,
                                           struct m0_be_reg_area        *ra);
M0_INTERNAL void
m0_be_reg_area_merger_merge_to(struct m0_be_reg_area_merger *brm,
                               struct m0_be_reg_area        *ra);

#endif /* __MOTR_BE_TX_REGMAP_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */