alloc.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_ALLOC_H__
#define __MOTR_BE_ALLOC_H__

#include "lib/types.h"  /* m0_bcount_t */
#include "lib/mutex.h"

struct m0_be_op;
struct m0_be_seg;
struct m0_be_tx;
struct m0_be_tx_credit;

enum {
        M0_BE_ALLOC_SHIFT_MIN  = 3,
};

struct m0_be_allocator_call_stat {
        unsigned long bcs_nr;
        m0_bcount_t   bcs_size;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_be_allocator_call_stats {
        struct m0_be_allocator_call_stat bacs_alloc_success;
        struct m0_be_allocator_call_stat bacs_alloc_failure;
        struct m0_be_allocator_call_stat bacs_free;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum {
        M0_BE_ALLOCATOR_STATS_BOUNDARY       = 1024,
        M0_BE_ALLOCATOR_STATS_PRINT_INTERVAL = 100,
};

enum m0_be_alloc_zone_type {
        M0_BAP_REPAIR,
        M0_BAP_NORMAL,
        /* Maybe more zones in the future. */
        M0_BAP_NR
} M0_XCA_ENUM;

struct m0_be_alloc_zone_stats {
        m0_bcount_t                        bzs_total;
        m0_bcount_t                        bzs_used;
        m0_bcount_t                        bzs_free;
        uint32_t                           bzs_type M0_XCA_FENUM(
                                                        m0_be_alloc_zone_type);
        struct m0_be_allocator_call_stats  bzs_stats;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_be_allocator_stats {
        m0_bcount_t                       bas_chunk_overhead;
        m0_bcount_t                       bas_space_total;
        m0_bcount_t                       bas_space_used;
        m0_bcount_t                       bas_space_free;
        m0_bcount_t                       bas_stat0_boundary;
        m0_bcount_t                       bas_chunks_nr;
        m0_bcount_t                       bas_free_chunks_nr;
        struct m0_be_allocator_call_stats bas_total;
        struct m0_be_allocator_call_stats bas_stat0;
        struct m0_be_allocator_call_stats bas_stat1;
        unsigned long                     bas_print_interval;
        unsigned long                     bas_print_index;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_be_allocator_header;

struct m0_be_allocator {
        struct m0_be_seg              *ba_seg;
        struct m0_mutex                ba_lock;
        struct m0_be_allocator_header *ba_h[M0_BAP_NR];
};

M0_INTERNAL int m0_be_allocator_init(struct m0_be_allocator *a,
                                     struct m0_be_seg *seg);

M0_INTERNAL void m0_be_allocator_fini(struct m0_be_allocator *a);

M0_INTERNAL bool m0_be_allocator__invariant(struct m0_be_allocator *a);

M0_INTERNAL int m0_be_allocator_create(struct m0_be_allocator *a,
                                       struct m0_be_tx        *tx,
                                       uint32_t               *zone_percent,
                                       uint32_t                zones_nr);

M0_INTERNAL void m0_be_allocator_destroy(struct m0_be_allocator *a,
                                         struct m0_be_tx *tx);

enum m0_be_allocator_op {
        M0_BAO_CREATE,  
        M0_BAO_DESTROY, 
        M0_BAO_ALLOC,         
        M0_BAO_ALLOC_ALIGNED, 
        M0_BAO_FREE,          
        M0_BAO_FREE_ALIGNED,  
};

M0_INTERNAL void m0_be_allocator_credit(struct m0_be_allocator *a,
                                        enum m0_be_allocator_op optype,
                                        m0_bcount_t size,
                                        unsigned shift,
                                        struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_be_alloc_aligned(struct m0_be_allocator *a,
                                     struct m0_be_tx *tx,
                                     struct m0_be_op *op,
                                     void **ptr,
                                     m0_bcount_t size,
                                     unsigned shift,
                                     uint64_t zonemask);

M0_INTERNAL void m0_be_alloc(struct m0_be_allocator *a,
                             struct m0_be_tx *tx,
                             struct m0_be_op *op,
                             void **ptr,
                             m0_bcount_t size);

M0_INTERNAL void m0_be_free_aligned(struct m0_be_allocator *a,
                                    struct m0_be_tx *tx,
                                    struct m0_be_op *op,
                                    void *ptr);

M0_INTERNAL void m0_be_free(struct m0_be_allocator *a,
                            struct m0_be_tx *tx,
                            struct m0_be_op *op,
                            void *ptr);
M0_INTERNAL void m0_be_alloc_stats(struct m0_be_allocator *a,
                                   struct m0_be_allocator_stats *out);

M0_INTERNAL void m0_be_alloc_stats_credit(struct m0_be_allocator *a,
                                          struct m0_be_tx_credit *accum);
M0_INTERNAL void m0_be_alloc_stats_capture(struct m0_be_allocator *a,
                                           struct m0_be_tx        *tx);


#define M0_BE_ALLOC_ARR(arr, nr, seg, tx, op)                           \
                m0_be_alloc(m0_be_seg_allocator(seg), (tx), (op),       \
                            (void **)&(arr), (nr) * sizeof((arr)[0]))

#define M0_BE_ALLOC_PTR(ptr, seg, tx, op)                               \
                M0_BE_ALLOC_ARR((ptr), 1, (seg), (tx), (op))

#define M0_BE_ALLOC_ARR_SYNC(arr, nr, seg, tx)                          \
                M0_BE_OP_SYNC(__op,                                     \
                              M0_BE_ALLOC_ARR((arr), (nr), (seg), (tx), &__op))

#define M0_BE_ALLOC_PTR_SYNC(ptr, seg, tx)                              \
                M0_BE_OP_SYNC(__op, M0_BE_ALLOC_PTR((ptr), (seg), (tx), &__op))

#define M0_BE_FREE_PTR(ptr, seg, tx, op)                                \
                m0_be_free(m0_be_seg_allocator(seg), (tx), (op), (ptr))

#define M0_BE_FREE_PTR_SYNC(ptr, seg, tx)                               \
                M0_BE_OP_SYNC(__op, M0_BE_FREE_PTR((ptr), (seg), (tx), &__op))

#define M0_BE_ALLOC_BUF(buf, seg, tx, op)                               \
                m0_be_alloc(m0_be_seg_allocator(seg), (tx), (op),       \
                            &(buf)->b_addr, (buf)->b_nob)

#define M0_BE_ALLOC_BUF_SYNC(buf, seg, tx)                              \
                M0_BE_OP_SYNC(__op, M0_BE_ALLOC_BUF((buf), (seg), (tx), &__op))

#define M0_BE_ALLOC_CREDIT_PTR(ptr, seg, accum)                         \
                m0_be_allocator_credit(m0_be_seg_allocator(seg),        \
                                       M0_BAO_ALLOC, sizeof *(ptr), 0, (accum))

#define M0_BE_FREE_CREDIT_PTR(ptr, seg, accum)                          \
                m0_be_allocator_credit(m0_be_seg_allocator(seg),        \
                                       M0_BAO_FREE, sizeof *(ptr), 0, (accum))

#define M0_BE_ALLOC_CREDIT_ARR(arr, nr, seg, accum)                             \
                m0_be_allocator_credit(m0_be_seg_allocator(seg),        \
                                       M0_BAO_ALLOC, (nr) * sizeof((arr)[0]), 0, (accum))

#define M0_BE_FREE_CREDIT_ARR(arr, nr, seg, accum)                              \
                m0_be_allocator_credit(m0_be_seg_allocator(seg),        \
                                       M0_BAO_FREE, (nr) * sizeof((arr)[0]), 0, (accum))

#define M0_BE_ALLOC_CREDIT_BUF(buf, seg, accum)                         \
                m0_be_allocator_credit(m0_be_seg_allocator(seg),        \
                                       M0_BAO_ALLOC, (buf)->b_nob, 0, (accum))


#endif /* __MOTR_BE_ALLOC_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
 */