PostgreSQL Source Code: contrib/pg_prewarm/pg_prewarm.c Source File

PostgreSQL Source Code git master
pg_prewarm.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * pg_prewarm.c
4 * prewarming utilities
5 *
6 * Copyright (c) 2010-2025, PostgreSQL Global Development Group
7 *
8 * IDENTIFICATION
9 * contrib/pg_prewarm/pg_prewarm.c
10 *
11 *-------------------------------------------------------------------------
12 */
13#include "postgres.h"
14
15#include <sys/stat.h>
16#include <unistd.h>
17
18#include "access/relation.h"
19#include "fmgr.h"
20#include "miscadmin.h"
21#include "storage/bufmgr.h"
22#include "storage/read_stream.h"
23#include "storage/smgr.h"
24#include "utils/acl.h"
25#include "utils/builtins.h"
26#include "utils/lsyscache.h"
27#include "utils/rel.h"
28
29 PG_MODULE_MAGIC_EXT(
30 .name = "pg_prewarm",
31 .version = PG_VERSION
32);
33
34 PG_FUNCTION_INFO_V1(pg_prewarm);
35
36 typedef enum
37{
38 PREWARM_PREFETCH,
39 PREWARM_READ,
40 PREWARM_BUFFER,
41} PrewarmType;
42
43 static PGIOAlignedBlock blockbuffer;
44
45/*
46 * pg_prewarm(regclass, mode text, fork text,
47 * first_block int8, last_block int8)
48 *
49 * The first argument is the relation to be prewarmed; the second controls
50 * how prewarming is done; legal options are 'prefetch', 'read', and 'buffer'.
51 * The third is the name of the relation fork to be prewarmed. The fourth
52 * and fifth arguments specify the first and last block to be prewarmed.
53 * If the fourth argument is NULL, it will be taken as 0; if the fifth argument
54 * is NULL, it will be taken as the number of blocks in the relation. The
55 * return value is the number of blocks successfully prewarmed.
56 */
57Datum
58 pg_prewarm(PG_FUNCTION_ARGS)
59{
60 Oid relOid;
61 text *forkName;
62 text *type;
63 int64 first_block;
64 int64 last_block;
65 int64 nblocks;
66 int64 blocks_done = 0;
67 int64 block;
68 Relation rel;
69 ForkNumber forkNumber;
70 char *forkString;
71 char *ttype;
72 PrewarmType ptype;
73 AclResult aclresult;
74
75 /* Basic sanity checking. */
76 if (PG_ARGISNULL(0))
77 ereport(ERROR,
78 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
79 errmsg("relation cannot be null")));
80 relOid = PG_GETARG_OID(0);
81 if (PG_ARGISNULL(1))
82 ereport(ERROR,
83 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
84 errmsg("prewarm type cannot be null")));
85 type = PG_GETARG_TEXT_PP(1);
86 ttype = text_to_cstring(type);
87 if (strcmp(ttype, "prefetch") == 0)
88 ptype = PREWARM_PREFETCH;
89 else if (strcmp(ttype, "read") == 0)
90 ptype = PREWARM_READ;
91 else if (strcmp(ttype, "buffer") == 0)
92 ptype = PREWARM_BUFFER;
93 else
94 {
95 ereport(ERROR,
96 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
97 errmsg("invalid prewarm type"),
98 errhint("Valid prewarm types are \"prefetch\", \"read\", and \"buffer\".")));
99 PG_RETURN_INT64(0); /* Placate compiler. */
100 }
101 if (PG_ARGISNULL(2))
102 ereport(ERROR,
103 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
104 errmsg("relation fork cannot be null")));
105 forkName = PG_GETARG_TEXT_PP(2);
106 forkString = text_to_cstring(forkName);
107 forkNumber = forkname_to_number(forkString);
108
109 /* Open relation and check privileges. */
110 rel = relation_open(relOid, AccessShareLock);
111 aclresult = pg_class_aclcheck(relOid, GetUserId(), ACL_SELECT);
112 if (aclresult != ACLCHECK_OK)
113 aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind), get_rel_name(relOid));
114
115 /* Check that the relation has storage. */
116 if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
117 ereport(ERROR,
118 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
119 errmsg("relation \"%s\" does not have storage",
120 RelationGetRelationName(rel)),
121 errdetail_relkind_not_supported(rel->rd_rel->relkind)));
122
123 /* Check that the fork exists. */
124 if (!smgrexists(RelationGetSmgr(rel), forkNumber))
125 ereport(ERROR,
126 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
127 errmsg("fork \"%s\" does not exist for this relation",
128 forkString)));
129
130 /* Validate block numbers, or handle nulls. */
131 nblocks = RelationGetNumberOfBlocksInFork(rel, forkNumber);
132 if (PG_ARGISNULL(3))
133 first_block = 0;
134 else
135 {
136 first_block = PG_GETARG_INT64(3);
137 if (first_block < 0 || first_block >= nblocks)
138 ereport(ERROR,
139 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
140 errmsg("starting block number must be between 0 and %" PRId64,
141 (nblocks - 1))));
142 }
143 if (PG_ARGISNULL(4))
144 last_block = nblocks - 1;
145 else
146 {
147 last_block = PG_GETARG_INT64(4);
148 if (last_block < 0 || last_block >= nblocks)
149 ereport(ERROR,
150 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
151 errmsg("ending block number must be between 0 and %" PRId64,
152 (nblocks - 1))));
153 }
154
155 /* Now we're ready to do the real work. */
156 if (ptype == PREWARM_PREFETCH)
157 {
158#ifdef USE_PREFETCH
159
160 /*
161 * In prefetch mode, we just hint the OS to read the blocks, but we
162 * don't know whether it really does it, and we don't wait for it to
163 * finish.
164 *
165 * It would probably be better to pass our prefetch requests in chunks
166 * of a megabyte or maybe even a whole segment at a time, but there's
167 * no practical way to do that at present without a gross modularity
168 * violation, so we just do this.
169 */
170 for (block = first_block; block <= last_block; ++block)
171 {
172 CHECK_FOR_INTERRUPTS();
173 PrefetchBuffer(rel, forkNumber, block);
174 ++blocks_done;
175 }
176#else
177 ereport(ERROR,
178 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
179 errmsg("prefetch is not supported by this build")));
180#endif
181 }
182 else if (ptype == PREWARM_READ)
183 {
184 /*
185 * In read mode, we actually read the blocks, but not into shared
186 * buffers. This is more portable than prefetch mode (it works
187 * everywhere) and is synchronous.
188 */
189 for (block = first_block; block <= last_block; ++block)
190 {
191 CHECK_FOR_INTERRUPTS();
192 smgrread(RelationGetSmgr(rel), forkNumber, block, blockbuffer.data);
193 ++blocks_done;
194 }
195 }
196 else if (ptype == PREWARM_BUFFER)
197 {
198 BlockRangeReadStreamPrivate p;
199 ReadStream *stream;
200
201 /*
202 * In buffer mode, we actually pull the data into shared_buffers.
203 */
204
205 /* Set up the private state for our streaming buffer read callback. */
206 p.current_blocknum = first_block;
207 p.last_exclusive = last_block + 1;
208
209 /*
210 * It is safe to use batchmode as block_range_read_stream_cb takes no
211 * locks.
212 */
213 stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
214 READ_STREAM_FULL |
215 READ_STREAM_USE_BATCHING,
216 NULL,
217 rel,
218 forkNumber,
219 block_range_read_stream_cb,
220 &p,
221 0);
222
223 for (block = first_block; block <= last_block; ++block)
224 {
225 Buffer buf;
226
227 CHECK_FOR_INTERRUPTS();
228 buf = read_stream_next_buffer(stream, NULL);
229 ReleaseBuffer(buf);
230 ++blocks_done;
231 }
232 Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
233 read_stream_end(stream);
234 }
235
236 /* Close relation, release lock. */
237 relation_close(rel, AccessShareLock);
238
239 PG_RETURN_INT64(blocks_done);
240}
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2652
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4037
int Buffer
Definition: buf.h:23
#define InvalidBuffer
Definition: buf.h:25
PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
Definition: bufmgr.c:651
BlockNumber RelationGetNumberOfBlocksInFork(Relation relation, ForkNumber forkNum)
Definition: bufmgr.c:4398
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5338
int64_t int64
Definition: c.h:535
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:150
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_ARGISNULL(n)
Definition: fmgr.h:209
#define PG_RETURN_INT64(x)
Definition: fmgr.h:368
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
Assert(PointerIsAligned(start, uint64))
#define AccessShareLock
Definition: lockdefs.h:36
char * get_rel_name(Oid relid)
Definition: lsyscache.c:2095
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
Oid GetUserId(void)
Definition: miscinit.c:469
ObjectType get_relkind_objtype(char relkind)
#define ACL_SELECT
Definition: parsenodes.h:77
int errdetail_relkind_not_supported(char relkind)
Definition: pg_class.c:24
PG_FUNCTION_INFO_V1(pg_prewarm)
PrewarmType
Definition: pg_prewarm.c:37
@ PREWARM_PREFETCH
Definition: pg_prewarm.c:38
@ PREWARM_READ
Definition: pg_prewarm.c:39
@ PREWARM_BUFFER
Definition: pg_prewarm.c:40
PG_MODULE_MAGIC_EXT(.name="pg_prewarm",.version=PG_VERSION)
static PGIOAlignedBlock blockbuffer
Definition: pg_prewarm.c:43
Datum pg_prewarm(PG_FUNCTION_ARGS)
Definition: pg_prewarm.c:58
static char * buf
Definition: pg_test_fsync.c:72
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
Definition: read_stream.c:791
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
Definition: read_stream.c:737
void read_stream_end(ReadStream *stream)
Definition: read_stream.c:1089
BlockNumber block_range_read_stream_cb(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: read_stream.c:162
#define READ_STREAM_MAINTENANCE
Definition: read_stream.h:28
#define READ_STREAM_USE_BATCHING
Definition: read_stream.h:64
#define READ_STREAM_FULL
Definition: read_stream.h:43
static SMgrRelation RelationGetSmgr(Relation rel)
Definition: rel.h:576
#define RelationGetRelationName(relation)
Definition: rel.h:548
ForkNumber forkname_to_number(const char *forkName)
Definition: relpath.c:50
ForkNumber
Definition: relpath.h:56
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:462
static void smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void *buffer)
Definition: smgr.h:124
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
BlockNumber last_exclusive
Definition: read_stream.h:73
BlockNumber current_blocknum
Definition: read_stream.h:72
Definition: rel.h:56
Form_pg_class rd_rel
Definition: rel.h:111
Definition: c.h:692
char data[BLCKSZ]
Definition: c.h:1136
char * text_to_cstring(const text *t)
Definition: varlena.c:214
const char * type
const char * name

AltStyle によって変換されたページ (->オリジナル) /