LCOV - differential code coverage report
Current view: top level - src/include/storage - block.h (source / functions) Coverage Total Hit CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 100.0 % 8 8 8
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 3 3 3
Baseline: 16@8cea358b128 Branches: - 0 0
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 100.0 % 8 8 8
Function coverage date bins:
(240..) days: 100.0 % 3 3 3

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * block.h
                                  4                 :                :  *    POSTGRES disk block definitions.
                                  5                 :                :  *
                                  6                 :                :  *
                                  7                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  8                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                  9                 :                :  *
                                 10                 :                :  * src/include/storage/block.h
                                 11                 :                :  *
                                 12                 :                :  *-------------------------------------------------------------------------
                                 13                 :                :  */
                                 14                 :                : #ifndef BLOCK_H
                                 15                 :                : #define BLOCK_H
                                 16                 :                : 
                                 17                 :                : /*
                                 18                 :                :  * BlockNumber:
                                 19                 :                :  *
                                 20                 :                :  * each data file (heap or index) is divided into postgres disk blocks
                                 21                 :                :  * (which may be thought of as the unit of i/o -- a postgres buffer
                                 22                 :                :  * contains exactly one disk block).  the blocks are numbered
                                 23                 :                :  * sequentially, 0 to 0xFFFFFFFE.
                                 24                 :                :  *
                                 25                 :                :  * InvalidBlockNumber is the same thing as P_NEW in bufmgr.h.
                                 26                 :                :  *
                                 27                 :                :  * the access methods, the buffer manager and the storage manager are
                                 28                 :                :  * more or less the only pieces of code that should be accessing disk
                                 29                 :                :  * blocks directly.
                                 30                 :                :  */
                                 31                 :                : typedef uint32 BlockNumber;
                                 32                 :                : 
                                 33                 :                : #define InvalidBlockNumber      ((BlockNumber) 0xFFFFFFFF)
                                 34                 :                : 
                                 35                 :                : #define MaxBlockNumber          ((BlockNumber) 0xFFFFFFFE)
                                 36                 :                : 
                                 37                 :                : /*
                                 38                 :                :  * BlockId:
                                 39                 :                :  *
                                 40                 :                :  * this is a storage type for BlockNumber.  in other words, this type
                                 41                 :                :  * is used for on-disk structures (e.g., in HeapTupleData) whereas
                                 42                 :                :  * BlockNumber is the type on which calculations are performed (e.g.,
                                 43                 :                :  * in access method code).
                                 44                 :                :  *
                                 45                 :                :  * there doesn't appear to be any reason to have separate types except
                                 46                 :                :  * for the fact that BlockIds can be SHORTALIGN'd (and therefore any
                                 47                 :                :  * structures that contains them, such as ItemPointerData, can also be
                                 48                 :                :  * SHORTALIGN'd).  this is an important consideration for reducing the
                                 49                 :                :  * space requirements of the line pointer (ItemIdData) array on each
                                 50                 :                :  * page and the header of each heap or index tuple, so it doesn't seem
                                 51                 :                :  * wise to change this without good reason.
                                 52                 :                :  */
                                 53                 :                : typedef struct BlockIdData
                                 54                 :                : {
                                 55                 :                :     uint16      bi_hi;
                                 56                 :                :     uint16      bi_lo;
                                 57                 :                : } BlockIdData;
                                 58                 :                : 
                                 59                 :                : typedef BlockIdData *BlockId;   /* block identifier */
                                 60                 :                : 
                                 61                 :                : /* ----------------
                                 62                 :                :  *      support functions
                                 63                 :                :  * ----------------
                                 64                 :                :  */
                                 65                 :                : 
                                 66                 :                : /*
                                 67                 :                :  * BlockNumberIsValid
                                 68                 :                :  *      True iff blockNumber is valid.
                                 69                 :                :  */
                                 70                 :                : static inline bool
  647 peter@eisentraut.org       71                 :CBC   133875309 : BlockNumberIsValid(BlockNumber blockNumber)
                                 72                 :                : {
                                 73                 :      133875309 :     return blockNumber != InvalidBlockNumber;
                                 74                 :                : }
                                 75                 :                : 
                                 76                 :                : /*
                                 77                 :                :  * BlockIdSet
                                 78                 :                :  *      Sets a block identifier to the specified value.
                                 79                 :                :  */
                                 80                 :                : static inline void
                                 81                 :      408497863 : BlockIdSet(BlockIdData *blockId, BlockNumber blockNumber)
                                 82                 :                : {
                                 83                 :      408497863 :     blockId->bi_hi = blockNumber >> 16;
                                 84                 :      408497863 :     blockId->bi_lo = blockNumber & 0xffff;
                                 85                 :      408497863 : }
                                 86                 :                : 
                                 87                 :                : /*
                                 88                 :                :  * BlockIdEquals
                                 89                 :                :  *      Check for block number equality.
                                 90                 :                :  */
                                 91                 :                : static inline bool
                                 92                 :                : BlockIdEquals(const BlockIdData *blockId1, const BlockIdData *blockId2)
                                 93                 :                : {
                                 94                 :                :     return (blockId1->bi_hi == blockId2->bi_hi &&
                                 95                 :                :             blockId1->bi_lo == blockId2->bi_lo);
                                 96                 :                : }
                                 97                 :                : 
                                 98                 :                : /*
                                 99                 :                :  * BlockIdGetBlockNumber
                                100                 :                :  *      Retrieve the block number from a block identifier.
                                101                 :                :  */
                                102                 :                : static inline BlockNumber
                                103                 :      249768713 : BlockIdGetBlockNumber(const BlockIdData *blockId)
                                104                 :                : {
                                105                 :      249768713 :     return (((BlockNumber) blockId->bi_hi) << 16) | ((BlockNumber) blockId->bi_lo);
                                106                 :                : }
                                107                 :                : 
                                108                 :                : #endif                          /* BLOCK_H */
        

Generated by: LCOV version 2.1-beta2-3-g6141622