/src/postgres/src/include/access/multixact_internal.h

Source
/*
 * multixact_internal.h
 *
 * PostgreSQL multi-transaction-log manager internal declarations
 *
 * These functions and definitions are for dealing with pg_multixact SLRU
 * pages.  They are internal to multixact.c, but they are exported here to
 * allow pg_upgrade to write pg_multixact files directly.
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/include/access/multixact_internal.h
 */
#ifndef MULTIXACT_INTERNAL_H

/*
 * Note: This is not only to prevent including this file twice.
 * MULTIXACT_INTERNAL_H is checked explicitly in multixact_read_v18.c.
 */
#define MULTIXACT_INTERNAL_H

#include "access/multixact.h"


/*
 * Defines for MultiXactOffset page sizes.  A page is the same BLCKSZ as is
 * used everywhere else in Postgres.
 */

/* We need 8 bytes per offset */
#define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))

static inline int64
MultiXactIdToOffsetPage(MultiXactId multi)
{
  return multi / MULTIXACT_OFFSETS_PER_PAGE;
}

static inline int
MultiXactIdToOffsetEntry(MultiXactId multi)
{
  return multi % MULTIXACT_OFFSETS_PER_PAGE;
}

static inline int64
MultiXactIdToOffsetSegment(MultiXactId multi)
{
  return MultiXactIdToOffsetPage(multi) / SLRU_PAGES_PER_SEGMENT;
}

/*
 * The situation for members is a bit more complex: we store one byte of
 * additional flag bits for each TransactionId.  To do this without getting
 * into alignment issues, we store four bytes of flags, and then the
 * corresponding 4 Xids.  Each such 5-word (20-byte) set we call a "group", and
 * are stored as a whole in pages.  Thus, with 8kB BLCKSZ, we keep 409 groups
 * per page.  This wastes 12 bytes per page, but that's OK -- simplicity (and
 * performance) trumps space efficiency here.
 *
 * Note that the "offset" macros work with byte offset, not array indexes, so
 * arithmetic must be done using "char *" pointers.
 */
/* We need eight bits per xact, so one xact fits in a byte */
#define MXACT_MEMBER_BITS_PER_XACT      8
#define MXACT_MEMBER_FLAGS_PER_BYTE     1
#define MXACT_MEMBER_XACT_BITMASK ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)

/* how many full bytes of flags are there in a group? */
#define MULTIXACT_FLAGBYTES_PER_GROUP   4
#define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
  (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
/* size in bytes of a complete group */
#define MULTIXACT_MEMBERGROUP_SIZE \
  (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
#define MULTIXACT_MEMBERGROUPS_PER_PAGE (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
#define MULTIXACT_MEMBERS_PER_PAGE  \
  (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)

/* page in which a member is to be found */
static inline int64
MXOffsetToMemberPage(MultiXactOffset offset)
{
  return offset / MULTIXACT_MEMBERS_PER_PAGE;
}

static inline int64
MXOffsetToMemberSegment(MultiXactOffset offset)
{
  return MXOffsetToMemberPage(offset) / SLRU_PAGES_PER_SEGMENT;
}

/* Location (byte offset within page) of flag word for a given member */
static inline int
MXOffsetToFlagsOffset(MultiXactOffset offset)
{
  MultiXactOffset group = offset / MULTIXACT_MEMBERS_PER_MEMBERGROUP;
  int     grouponpg = group % MULTIXACT_MEMBERGROUPS_PER_PAGE;
  int     byteoff = grouponpg * MULTIXACT_MEMBERGROUP_SIZE;

  return byteoff;
}

static inline int
MXOffsetToFlagsBitShift(MultiXactOffset offset)
{
  int     member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
  int     bshift = member_in_group * MXACT_MEMBER_BITS_PER_XACT;

  return bshift;
}

/* Location (byte offset within page) of TransactionId of given member */
static inline int
MXOffsetToMemberOffset(MultiXactOffset offset)
{
  int     member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;

  return MXOffsetToFlagsOffset(offset) +
    MULTIXACT_FLAGBYTES_PER_GROUP +
    member_in_group * sizeof(TransactionId);
}

/* Storage space consumed by a range of offsets, in bytes */
static inline uint64
MultiXactOffsetStorageSize(MultiXactOffset new_offset,
               MultiXactOffset old_offset)
{
  uint64    size_per_member;

  Assert(new_offset >= old_offset);
  size_per_member = MULTIXACT_MEMBERGROUP_SIZE / MULTIXACT_MEMBERS_PER_MEMBERGROUP;
  return (new_offset - old_offset) * size_per_member;
}

#endif              /* MULTIXACT_INTERNAL_H */

Line	Count	Source
1		/*
2		* multixact_internal.h
3		*
4		* PostgreSQL multi-transaction-log manager internal declarations
5		*
6		* These functions and definitions are for dealing with pg_multixact SLRU
7		* pages. They are internal to multixact.c, but they are exported here to
8		* allow pg_upgrade to write pg_multixact files directly.
9		*
10		* Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
11		* Portions Copyright (c) 1994, Regents of the University of California
12		*
13		* src/include/access/multixact_internal.h
14		*/
15		#ifndef MULTIXACT_INTERNAL_H
16
17		/*
18		* Note: This is not only to prevent including this file twice.
19		* MULTIXACT_INTERNAL_H is checked explicitly in multixact_read_v18.c.
20		*/
21		#define MULTIXACT_INTERNAL_H
22
23		#include "access/multixact.h"
24
25
26		/*
27		* Defines for MultiXactOffset page sizes. A page is the same BLCKSZ as is
28		* used everywhere else in Postgres.
29		*/
30
31		/* We need 8 bytes per offset */
32	0	#define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
33
34		static inline int64
35		MultiXactIdToOffsetPage(MultiXactId multi)
36	0	{
37	0	return multi / MULTIXACT_OFFSETS_PER_PAGE;
38	0	} Unexecuted instantiation: multixact.c:MultiXactIdToOffsetPage Unexecuted instantiation: multixactfuncs.c:MultiXactIdToOffsetPage
39
40		static inline int
41		MultiXactIdToOffsetEntry(MultiXactId multi)
42	0	{
43	0	return multi % MULTIXACT_OFFSETS_PER_PAGE;
44	0	} Unexecuted instantiation: multixact.c:MultiXactIdToOffsetEntry Unexecuted instantiation: multixactfuncs.c:MultiXactIdToOffsetEntry
45
46		static inline int64
47		MultiXactIdToOffsetSegment(MultiXactId multi)
48	0	{
49	0	return MultiXactIdToOffsetPage(multi) / SLRU_PAGES_PER_SEGMENT;
50	0	} Unexecuted instantiation: multixact.c:MultiXactIdToOffsetSegment Unexecuted instantiation: multixactfuncs.c:MultiXactIdToOffsetSegment
51
52		/*
53		* The situation for members is a bit more complex: we store one byte of
54		* additional flag bits for each TransactionId. To do this without getting
55		* into alignment issues, we store four bytes of flags, and then the
56		* corresponding 4 Xids. Each such 5-word (20-byte) set we call a "group", and
57		* are stored as a whole in pages. Thus, with 8kB BLCKSZ, we keep 409 groups
58		* per page. This wastes 12 bytes per page, but that's OK -- simplicity (and
59		* performance) trumps space efficiency here.
60		*
61		* Note that the "offset" macros work with byte offset, not array indexes, so
62		* arithmetic must be done using "char *" pointers.
63		*/
64		/* We need eight bits per xact, so one xact fits in a byte */
65	0	#define MXACT_MEMBER_BITS_PER_XACT 8
66	0	#define MXACT_MEMBER_FLAGS_PER_BYTE 1
67	0	#define MXACT_MEMBER_XACT_BITMASK ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
68
69		/* how many full bytes of flags are there in a group? */
70	0	#define MULTIXACT_FLAGBYTES_PER_GROUP 4
71		#define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
72	0	(MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
73		/* size in bytes of a complete group */
74		#define MULTIXACT_MEMBERGROUP_SIZE \
75	0	(sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
76	0	#define MULTIXACT_MEMBERGROUPS_PER_PAGE (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
77		#define MULTIXACT_MEMBERS_PER_PAGE \
78	0	(MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)
79
80		/* page in which a member is to be found */
81		static inline int64
82		MXOffsetToMemberPage(MultiXactOffset offset)
83	0	{
84	0	return offset / MULTIXACT_MEMBERS_PER_PAGE;
85	0	} Unexecuted instantiation: multixact.c:MXOffsetToMemberPage Unexecuted instantiation: multixactfuncs.c:MXOffsetToMemberPage
86
87		static inline int64
88		MXOffsetToMemberSegment(MultiXactOffset offset)
89	0	{
90	0	return MXOffsetToMemberPage(offset) / SLRU_PAGES_PER_SEGMENT;
91	0	} Unexecuted instantiation: multixact.c:MXOffsetToMemberSegment Unexecuted instantiation: multixactfuncs.c:MXOffsetToMemberSegment
92
93		/* Location (byte offset within page) of flag word for a given member */
94		static inline int
95		MXOffsetToFlagsOffset(MultiXactOffset offset)
96	0	{
97	0	MultiXactOffset group = offset / MULTIXACT_MEMBERS_PER_MEMBERGROUP;
98	0	int grouponpg = group % MULTIXACT_MEMBERGROUPS_PER_PAGE;
99	0	int byteoff = grouponpg * MULTIXACT_MEMBERGROUP_SIZE;
100
101	0	return byteoff;
102	0	} Unexecuted instantiation: multixact.c:MXOffsetToFlagsOffset Unexecuted instantiation: multixactfuncs.c:MXOffsetToFlagsOffset
103
104		static inline int
105		MXOffsetToFlagsBitShift(MultiXactOffset offset)
106	0	{
107	0	int member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
108	0	int bshift = member_in_group * MXACT_MEMBER_BITS_PER_XACT;
109
110	0	return bshift;
111	0	} Unexecuted instantiation: multixact.c:MXOffsetToFlagsBitShift Unexecuted instantiation: multixactfuncs.c:MXOffsetToFlagsBitShift
112
113		/* Location (byte offset within page) of TransactionId of given member */
114		static inline int
115		MXOffsetToMemberOffset(MultiXactOffset offset)
116	0	{
117	0	int member_in_group = offset % MULTIXACT_MEMBERS_PER_MEMBERGROUP;
118
119	0	return MXOffsetToFlagsOffset(offset) +
120	0	MULTIXACT_FLAGBYTES_PER_GROUP +
121	0	member_in_group * sizeof(TransactionId);
122	0	} Unexecuted instantiation: multixact.c:MXOffsetToMemberOffset Unexecuted instantiation: multixactfuncs.c:MXOffsetToMemberOffset
123
124		/* Storage space consumed by a range of offsets, in bytes */
125		static inline uint64
126		MultiXactOffsetStorageSize(MultiXactOffset new_offset,
127		MultiXactOffset old_offset)
128	0	{
129	0	uint64 size_per_member;
130
131	0	Assert(new_offset >= old_offset);
132	0	size_per_member = MULTIXACT_MEMBERGROUP_SIZE / MULTIXACT_MEMBERS_PER_MEMBERGROUP;
133	0	return (new_offset - old_offset) * size_per_member;
134	0	} Unexecuted instantiation: multixact.c:MultiXactOffsetStorageSize Unexecuted instantiation: multixactfuncs.c:MultiXactOffsetStorageSize
135
136		#endif /* MULTIXACT_INTERNAL_H */

Coverage Report

Created: 2026-09-28 06:55