Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

gh-95335: reduce stack consumption in the compiler #95333

Closed
wants to merge 7 commits into from
+62 −66
Closed

gh-95335: reduce stack consumption in the compiler #95333

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
5f881d9
gh-93678: inline a few compiler functions to reverse the recent incre…
iritkatriel Jul 27, 2022
93307ce
convert cfg_builder_addop_noarg to macro
iritkatriel Jul 27, 2022
0fc800b
turn cfg_builder_addop_j into a macro
iritkatriel Jul 27, 2022
d347ba7
turn cfg_builder_addop_i into a macro
iritkatriel Jul 27, 2022
6f7d1b4
unskip tests
iritkatriel Jul 27, 2022
8d9a06f
Revert "turn cfg_builder_addop_i into a macro"
iritkatriel Jul 27, 2022
f1f655e
turn cfg_builder_addop_i into a macro
iritkatriel Jul 28, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 0 additions & 2 deletions Lib/test/test_compile.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -108,7 +108,6 @@ def __getitem__(self, key):
exec('z = a', g, d)
self.assertEqual(d['z'], 12)

@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
def test_extended_arg(self):
# default: 1000 * 2.5 = 2500 repetitions
repeat = int(sys.getrecursionlimit() * 2.5)
Expand Down Expand Up @@ -543,7 +542,6 @@ def test_yet_more_evil_still_undecodable(self):
self.assertIn(b"Non-UTF-8", res.err)

@support.cpython_only
@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
def test_compiler_recursion_limit(self):
# Expected limit is sys.getrecursionlimit() * the scaling factor
# in symtable.c (currently 3)
Expand Down
126 changes: 62 additions & 64 deletions Python/compile.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -134,11 +134,15 @@ struct location {
int end_col_offset;
};


#define LOCATION(LNO, END_LNO, COL, END_COL) \
((const struct location){(LNO), (END_LNO), (COL), (END_COL)})

static struct location NO_LOCATION = {-1, -1, -1, -1};

#define NO_OPARG -1
#define NO_TARGET NULL

struct instr {
int i_opcode;
int i_oparg;
Expand Down Expand Up @@ -429,8 +433,6 @@ typedef struct {

static int basicblock_next_instr(basicblock *);

static int cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, struct location loc);

static void compiler_free(struct compiler *);
static int compiler_error(struct compiler *, const char *, ...);
static int compiler_warn(struct compiler *, const char *, ...);
Expand Down Expand Up @@ -866,13 +868,13 @@ cfg_builder_use_next_block(cfg_builder *g, basicblock *block)
return block;
}

static basicblock *
static inline basicblock *
compiler_new_block(struct compiler *c)
{
return cfg_builder_new_block(CFG_BUILDER(c));
}

static basicblock *
static inline basicblock *
compiler_use_next_block(struct compiler *c, basicblock *block)
{
return cfg_builder_use_next_block(CFG_BUILDER(c), block);
Expand Down Expand Up @@ -1248,23 +1250,34 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
return stack_effect(opcode, oparg, -1);
}

/* Add an opcode with no argument.
Returns 0 on failure, 1 on success.
*/
#define HAS_TARGET(opcode) \
(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode))

static int
/* Append an instruction. Returns 0 on failure, 1 on success. */
static inline int
basicblock_addop(basicblock *b, int opcode, int oparg,
basicblock *target, struct location loc)
{
assert(IS_WITHIN_OPCODE_RANGE(opcode));
assert(!IS_ASSEMBLER_OPCODE(opcode));
assert(HAS_ARG(opcode) || oparg == 0);
assert(0 <= oparg && oparg < (1 << 30));
assert((target == NULL) ||
IS_JUMP_OPCODE(opcode) ||
IS_BLOCK_PUSH_OPCODE(opcode));
assert(oparg == 0 || target == NULL);
assert(oparg == NO_OPARG || (0 <= oparg && oparg < (1 << 30)));
assert((HAS_ARG(opcode) && !HAS_TARGET(opcode) && oparg != NO_OPARG) ||
(!(HAS_ARG(opcode) && !HAS_TARGET(opcode)) && oparg == NO_OPARG));
assert((HAS_TARGET(opcode) && target != NO_TARGET) ||
(!HAS_TARGET(opcode) && target == NO_TARGET));
assert(!(oparg != NO_OPARG && target != NO_TARGET));

if (oparg != NO_OPARG) {
/* oparg value is unsigned, but a signed C int is usually used to store
it in the C code (like Python/ceval.c).

Limit to 32-bit signed C int (rather than INT_MAX) for portability.

The argument of a concrete bytecode instruction is limited to 8-bit.
EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */

oparg = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);
}
int off = basicblock_next_instr(b);
if (off < 0) {
return 0;
Expand All @@ -1278,7 +1291,7 @@ basicblock_addop(basicblock *b, int opcode, int oparg,
return 1;
}

static int
static inline int
cfg_builder_addop(cfg_builder *g, int opcode, int oparg, basicblock *target,
struct location loc)
{
Expand All @@ -1293,12 +1306,17 @@ cfg_builder_addop(cfg_builder *g, int opcode, int oparg, basicblock *target,
return basicblock_addop(g->curblock, opcode, oparg, target, loc);
}

static int
cfg_builder_addop_noarg(cfg_builder *g, int opcode, struct location loc)
{
assert(!HAS_ARG(opcode));
return cfg_builder_addop(g, opcode, 0, NULL, loc);
}
/* Add an instruction with no arg. Returns 0 on failure, 1 on success. */
#define CFG_BUILDER_ADDOP_NOARG(G, OP, LOC) \
cfg_builder_addop(G, OP, NO_OPARG, NO_TARGET, LOC)

/* Add an instruction with an integer arg. Returns 0 on failure, 1 on success. */
#define CFG_BUILDER_ADDOP_I(G, OP, ARG, LOC) \
cfg_builder_addop(G, OP, ARG, NO_TARGET, LOC)

/* Add a jump instruction. Returns 0 on faiure, 1 on success. */
#define CFG_BUILDER_ADDOP_J(G, OP, T, LOC) \
cfg_builder_addop(G, OP, NO_OPARG, T, LOC)

static Py_ssize_t
dict_add_o(PyObject *dict, PyObject *o)
Expand Down Expand Up @@ -1457,7 +1475,7 @@ compiler_addop_load_const(struct compiler *c, PyObject *o)
Py_ssize_t arg = compiler_add_const(c, o);
if (arg < 0)
return 0;
return cfg_builder_addop_i(CFG_BUILDER(c), LOAD_CONST, arg, COMPILER_LOC(c));
return CFG_BUILDER_ADDOP_I(CFG_BUILDER(c), LOAD_CONST, arg, COMPILER_LOC(c));
}

static int
Expand All @@ -1467,7 +1485,8 @@ compiler_addop_o(struct compiler *c, int opcode, PyObject *dict,
Py_ssize_t arg = dict_add_o(dict, o);
if (arg < 0)
return 0;
return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, COMPILER_LOC(c));
assert(HAS_ARG(opcode));
return CFG_BUILDER_ADDOP_I(CFG_BUILDER(c), opcode, arg, COMPILER_LOC(c));
}

static int
Expand All @@ -1491,48 +1510,21 @@ compiler_addop_name(struct compiler *c, int opcode, PyObject *dict,
arg <<= 1;
arg |= 1;
}
return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, COMPILER_LOC(c));
}

/* Add an opcode with an integer argument.
Returns 0 on failure, 1 on success.
*/
static int
cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, struct location loc)
{
/* oparg value is unsigned, but a signed C int is usually used to store
it in the C code (like Python/ceval.c).

Limit to 32-bit signed C int (rather than INT_MAX) for portability.

The argument of a concrete bytecode instruction is limited to 8-bit.
EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */

int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);
return cfg_builder_addop(g, opcode, oparg_, NULL, loc);
}

static int
cfg_builder_addop_j(cfg_builder *g, int opcode, basicblock *target, struct location loc)
{
assert(target != NULL);
assert(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode));
return cfg_builder_addop(g, opcode, 0, target, loc);
return CFG_BUILDER_ADDOP_I(CFG_BUILDER(c), opcode, arg, COMPILER_LOC(c));
}


#define ADDOP(C, OP) { \
if (!cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), COMPILER_LOC(C))) \
if (!CFG_BUILDER_ADDOP_NOARG(CFG_BUILDER(C), (OP), COMPILER_LOC(C))) \
return 0; \
}

#define ADDOP_NOLINE(C, OP) { \
if (!cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), NO_LOCATION)) \
if (!CFG_BUILDER_ADDOP_NOARG(CFG_BUILDER(C), (OP), NO_LOCATION)) \
return 0; \
}

#define ADDOP_IN_SCOPE(C, OP) { \
if (!cfg_builder_addop_noarg(CFG_BUILDER(C), (OP), COMPILER_LOC(C))) { \
if (!CFG_BUILDER_ADDOP_NOARG(CFG_BUILDER(C), (OP), COMPILER_LOC(C))) { \
compiler_exit_scope(c); \
return 0; \
} \
Expand Down Expand Up @@ -1571,25 +1563,29 @@ cfg_builder_addop_j(cfg_builder *g, int opcode, basicblock *target, struct locat
}

#define ADDOP_I(C, OP, O) { \
if (!cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), COMPILER_LOC(C))) \
assert(HAS_ARG(OP)); \
if (!CFG_BUILDER_ADDOP_I(CFG_BUILDER(C), (OP), (O), COMPILER_LOC(C))) \
return 0; \
}

#define ADDOP_I_NOLINE(C, OP, O) { \
if (!cfg_builder_addop_i(CFG_BUILDER(C), (OP), (O), NO_LOCATION)) \
assert(HAS_ARG(OP)); \
if (!CFG_BUILDER_ADDOP_I(CFG_BUILDER(C), (OP), (O), NO_LOCATION)) \
return 0; \
}

#define ADDOP_JUMP(C, OP, O) { \
if (!cfg_builder_addop_j(CFG_BUILDER(C), (OP), (O), COMPILER_LOC(C))) \
assert(HAS_TARGET(OP) && (O) != NO_TARGET); \
if (!CFG_BUILDER_ADDOP_J(CFG_BUILDER(C), (OP), (O), COMPILER_LOC(C))) \
return 0; \
}

/* Add a jump with no line number.
* Used for artificial jumps that have no corresponding
* token in the source code. */
#define ADDOP_JUMP_NOLINE(C, OP, O) { \
if (!cfg_builder_addop_j(CFG_BUILDER(C), (OP), (O), NO_LOCATION)) \
assert(HAS_TARGET(OP) && (O) != NO_TARGET); \
if (!CFG_BUILDER_ADDOP_J(CFG_BUILDER(C), (OP), (O), NO_LOCATION)) \
return 0; \
}

Expand Down Expand Up @@ -4237,7 +4233,8 @@ compiler_nameop(struct compiler *c, identifier name, expr_context_ty ctx)
if (op == LOAD_GLOBAL) {
arg <<= 1;
}
return cfg_builder_addop_i(CFG_BUILDER(c), op, arg, COMPILER_LOC(c));
assert(HAS_ARG(op));
return CFG_BUILDER_ADDOP_I(CFG_BUILDER(c), op, arg, COMPILER_LOC(c));
}

static int
Expand Down Expand Up @@ -6280,7 +6277,7 @@ emit_and_reset_fail_pop(struct compiler *c, pattern_context *pc)
}
while (--pc->fail_pop_size) {
compiler_use_next_block(c, pc->fail_pop[pc->fail_pop_size]);
if (!cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, COMPILER_LOC(c))) {
if (!CFG_BUILDER_ADDOP_NOARG(CFG_BUILDER(c), POP_TOP, COMPILER_LOC(c))) {
pc->fail_pop_size = 0;
PyObject_Free(pc->fail_pop);
pc->fail_pop = NULL;
Expand Down Expand Up @@ -6714,7 +6711,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc)
pc->fail_pop = NULL;
pc->fail_pop_size = 0;
pc->on_top = 0;
if (!cfg_builder_addop_i(CFG_BUILDER(c), COPY, 1, COMPILER_LOC(c)) ||
if (!CFG_BUILDER_ADDOP_I(CFG_BUILDER(c), COPY, 1, COMPILER_LOC(c)) ||
!compiler_pattern(c, alt, pc)) {
goto error;
}
Expand Down Expand Up @@ -6778,7 +6775,8 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc)
}
}
assert(control);
if (!cfg_builder_addop_j(CFG_BUILDER(c), JUMP, end, COMPILER_LOC(c)) ||
assert(end);
if (!CFG_BUILDER_ADDOP_J(CFG_BUILDER(c), JUMP, end, COMPILER_LOC(c)) ||
!emit_and_reset_fail_pop(c, pc))
{
goto error;
Expand All @@ -6790,7 +6788,7 @@ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc)
// Need to NULL this for the PyObject_Free call in the error block.
old_pc.fail_pop = NULL;
// No match. Pop the remaining copy of the subject and fail:
if (!cfg_builder_addop_noarg(CFG_BUILDER(c), POP_TOP, COMPILER_LOC(c)) || !jump_to_fail_pop(c, pc, JUMP)) {
if (!CFG_BUILDER_ADDOP_NOARG(CFG_BUILDER(c), POP_TOP, COMPILER_LOC(c)) || !jump_to_fail_pop(c, pc, JUMP)) {
goto error;
}
compiler_use_next_block(c, end);
Expand Down Expand Up @@ -7438,7 +7436,7 @@ push_cold_blocks_to_end(cfg_builder *g, int code_flags) {
if (explicit_jump == NULL) {
return -1;
}
basicblock_addop(explicit_jump, JUMP, 0, b->b_next, NO_LOCATION);
basicblock_addop(explicit_jump, JUMP, NO_OPARG, b->b_next, NO_LOCATION);

explicit_jump->b_cold = 1;
explicit_jump->b_next = b->b_next;
Expand Down