← Back to branch summary

~vcs-imports/mammoth-replicator/trunk

« back to all changes in this revision

Viewing changes to src/include/utils/pg_lzcompress.h

  • Committer: alvherre
  • Date: 2005-12-16 21:24:52 UTC
  • Revision ID: svn-v4:db760fc0-0f08-0410-9d63-cc6633f64896:trunk:1
Initial import of the REL8_0_3 sources from the Pgsql CVS repository.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/include/utils/pg_lzcompress.h
 
1
/* ----------
 
2
 * pg_lzcompress.h -
 
3
 *
 
4
 * $PostgreSQL: pgsql/src/include/utils/pg_lzcompress.h,v 1.10 2003-11-29 19:52:08 pgsql Exp $
 
5
 *
 
6
 *      Definitions for the builtin LZ compressor
 
7
 * ----------
 
8
 */
 
9
 
 
10
#ifndef _PG_LZCOMPRESS_H_
 
11
#define _PG_LZCOMPRESS_H_
 
12
 
 
13
 
 
14
/* ----------
 
15
 * PGLZ_Header -
 
16
 *
 
17
 *              The information at the top of the compressed data.
 
18
 *              The varsize must be kept the same data type as the value
 
19
 *              in front of all variable size data types in PostgreSQL.
 
20
 * ----------
 
21
 */
 
22
typedef struct PGLZ_Header
 
23
{
 
24
        int32           varsize;
 
25
        int32           rawsize;
 
26
} PGLZ_Header;
 
27
 
 
28
 
 
29
/* ----------
 
30
 * PGLZ_MAX_OUTPUT -
 
31
 *
 
32
 *              Macro to compute the maximum buffer required for the
 
33
 *              compression output. It is larger than the input, because
 
34
 *              in the worst case, we cannot write out one single tag but
 
35
 *              need one control byte per 8 literal data bytes plus the
 
36
 *              EOF mark at the end.
 
37
 * ----------
 
38
 */
 
39
#define PGLZ_MAX_OUTPUT(_dlen)                  ((_dlen) + (((_dlen) | 0x07) >> 3)      \
 
40
                                                                                                         + sizeof(PGLZ_Header))
 
41
 
 
42
/* ----------
 
43
 * PGLZ_RAW_SIZE -
 
44
 *
 
45
 *              Macro to determine the uncompressed data size contained
 
46
 *              in the entry.
 
47
 * ----------
 
48
 */
 
49
#define PGLZ_RAW_SIZE(_lzdata)                  (_lzdata->rawsize)
 
50
 
 
51
/* ----------
 
52
 * PGLZ_IS_COMPRESSED -
 
53
 *
 
54
 *              Macro to determine if the data itself is stored as raw
 
55
 *              uncompressed data.
 
56
 * ----------
 
57
 */
 
58
#define PGLZ_IS_COMPRESSED(_lzdata)             (_lzdata->varsize !=                            \
 
59
                                                                                 _lzdata->rawsize +                                     \
 
60
                                                                                                                sizeof(PGLZ_Header))
 
61
 
 
62
/* ----------
 
63
 * PGLZ_RAW_DATA -
 
64
 *
 
65
 *              Macro to get access to the plain compressed or uncompressed
 
66
 *              data. Useful if PGLZ_IS_COMPRESSED returns false.
 
67
 * ----------
 
68
 */
 
69
#define PGLZ_RAW_DATA(_lzdata)                  (((char *)(_lzdata)) +                          \
 
70
                                                                                                                sizeof(PGLZ_Header))
 
71
 
 
72
/* ----------
 
73
 * PGLZ_Strategy -
 
74
 *
 
75
 *              Some values that control the compression algorithm.
 
76
 *
 
77
 *              min_input_size          Minimum input data size to start compression.
 
78
 *
 
79
 *              force_input_size        Input data size at which compressed storage is
 
80
 *                                                      forced even if the compression rate drops below
 
81
 *                                                      min_comp_rate (but not below 0).
 
82
 *
 
83
 *              min_comp_rate           Minimum compression rate (0-99%), the output
 
84
 *                                                      must be smaller than the input. If that isn't
 
85
 *                                                      the case, the compressor will throw away its
 
86
 *                                                      output and copy the original, uncompressed data
 
87
 *                                                      to the output buffer.
 
88
 *
 
89
 *              match_size_good         The initial GOOD match size when starting history
 
90
 *                                                      lookup. When looking up the history to find a
 
91
 *                                                      match that could be expressed as a tag, the
 
92
 *                                                      algorithm does not always walk back entirely.
 
93
 *                                                      A good match fast is usually better than the
 
94
 *                                                      best possible one very late. For each iteration
 
95
 *                                                      in the lookup, this value is lowered so the
 
96
 *                                                      longer the lookup takes, the smaller matches
 
97
 *                                                      are considered good.
 
98
 *
 
99
 *              match_size_drop         The percentage, match_size_good is lowered
 
100
 *                                                      at each history check. Allowed values are
 
101
 *                                                      0 (no change until end) to 100 (only check
 
102
 *                                                      latest history entry at all).
 
103
 * ----------
 
104
 */
 
105
typedef struct PGLZ_Strategy
 
106
{
 
107
        int32           min_input_size;
 
108
        int32           force_input_size;
 
109
        int32           min_comp_rate;
 
110
        int32           match_size_good;
 
111
        int32           match_size_drop;
 
112
} PGLZ_Strategy;
 
113
 
 
114
 
 
115
/* ----------
 
116
 * PGLZ_DecompState -
 
117
 *
 
118
 *              Decompression state variable for byte-per-byte decompression
 
119
 *              using pglz_decomp_getchar() macro.
 
120
 * ----------
 
121
 */
 
122
typedef struct PGLZ_DecompState
 
123
{
 
124
        unsigned char *temp_buf;
 
125
        unsigned char *cp_in;
 
126
        unsigned char *cp_end;
 
127
        unsigned char *cp_out;
 
128
        unsigned char *cp_copy;
 
129
        int                     (*next_char) (struct PGLZ_DecompState *dstate);
 
130
        int                     tocopy;
 
131
        int                     ctrl_count;
 
132
        unsigned char ctrl;
 
133
} PGLZ_DecompState;
 
134
 
 
135
 
 
136
/* ----------
 
137
 * The standard strategies
 
138
 *
 
139
 *              PGLZ_strategy_default           Starts compression only if input is
 
140
 *                                                                      at least 256 bytes large. Stores output
 
141
 *                                                                      uncompressed if compression does not
 
142
 *                                                                      gain at least 20% size reducture but
 
143
 *                                                                      input does not exceed 6K. Stops history
 
144
 *                                                                      lookup if at least a 128 byte long
 
145
 *                                                                      match has been found.
 
146
 *
 
147
 *                                                                      This is the default strategy if none
 
148
 *                                                                      is given to pglz_compress().
 
149
 *
 
150
 *              PGLZ_strategy_always            Starts compression on any infinitely
 
151
 *                                                                      small input and does fallback to
 
152
 *                                                                      uncompressed storage only if output
 
153
 *                                                                      would be larger than input.
 
154
 *
 
155
 *              PGLZ_strategy_never                     Force pglz_compress to act as a custom
 
156
 *                                                                      interface for memcpy(). Only useful
 
157
 *                                                                      for generic interfacing.
 
158
 * ----------
 
159
 */
 
160
extern PGLZ_Strategy *PGLZ_strategy_default;
 
161
extern PGLZ_Strategy *PGLZ_strategy_always;
 
162
extern PGLZ_Strategy *PGLZ_strategy_never;
 
163
 
 
164
 
 
165
/* ----------
 
166
 * pglz_decomp_getchar -
 
167
 *
 
168
 *              Get next character (or EOF) from decompressor.
 
169
 *              The status variable must be initialized before and deinitialized
 
170
 *              after compression with the next two macros below.
 
171
 * ----------
 
172
 */
 
173
#define pglz_decomp_getchar(_ds)                                                                                        \
 
174
        ((*((_ds)->next_char))((_ds)))
 
175
 
 
176
 
 
177
/* ----------
 
178
 * pglz_decomp_init -
 
179
 *
 
180
 *              Initialize a decomp state from a compressed input.
 
181
 * ----------
 
182
 */
 
183
#define pglz_decomp_init(_ds,_lz) do {                                                                                  \
 
184
                (_ds)->cp_in            = ((unsigned char *)(_lz))                                              \
 
185
                                                                                        + sizeof(PGLZ_Header);                  \
 
186
                (_ds)->cp_end           = (_ds)->cp_in + (_lz)->varsize                                 \
 
187
                                                                                        - sizeof(PGLZ_Header);                  \
 
188
                if (PGLZ_IS_COMPRESSED((_lz))) {                                                                        \
 
189
                        (_ds)->temp_buf         = (unsigned char *)                                                     \
 
190
                                                                                palloc(PGLZ_RAW_SIZE((_lz)));           \
 
191
                        (_ds)->cp_out           = (_ds)->temp_buf;                                                      \
 
192
                        (_ds)->next_char        = pglz_get_next_decomp_char_from_lzdata;        \
 
193
                        (_ds)->tocopy           = 0;                                                                            \
 
194
                        (_ds)->ctrl_count       = 0;                                                                            \
 
195
                } else {                                                                                                                        \
 
196
                        (_ds)->temp_buf         = NULL;                                                                         \
 
197
                        (_ds)->next_char        = pglz_get_next_decomp_char_from_plain;         \
 
198
                }                                                                                                                                       \
 
199
        } while (0)
 
200
 
 
201
 
 
202
/* ----------
 
203
 * pglz_decomp_end -
 
204
 *
 
205
 *              Deallocate resources after decompression.
 
206
 * ----------
 
207
 */
 
208
#define pglz_decomp_end(_ds) do {                                                                                       \
 
209
                if ((_ds)->temp_buf != NULL)                                                                            \
 
210
                        pfree((void *)((_ds)->temp_buf));                                                               \
 
211
        } while (0)
 
212
 
 
213
 
 
214
/* ----------
 
215
 * Global function declarations
 
216
 * ----------
 
217
 */
 
218
int pglz_compress(char *source, int32 slen, PGLZ_Header *dest,
 
219
                          PGLZ_Strategy *strategy);
 
220
int                     pglz_decompress(PGLZ_Header *source, char *dest);
 
221
 
 
222
 
 
223
/* ----------
 
224
 * Functions used by pglz_decomp_getchar().
 
225
 * Internal use only.
 
226
 * ----------
 
227
 */
 
228
extern int      pglz_get_next_decomp_char_from_lzdata(PGLZ_DecompState *dstate);
 
229
extern int      pglz_get_next_decomp_char_from_plain(PGLZ_DecompState *dstate);
 
230
 
 
231
#endif   /* _PG_LZCOMPRESS_H_ */