Infinite recursion[edit]Main articl

Infinite recursion[edit]
Main article: Infinite recursion
The most common cause of stack overflow is excessively deep or infinite recursion. Languages like Scheme, which implement tail-call optimization, allow infinite recursion of a specific sort—tail recursion—to occur without stack overflow. This works because tail-recursion calls do not take up additional stack space.[2]

An example of infinite recursion in C.

int foo()
{
return foo();
}
The function foo, when it is invoked, continues to invoke itself, using additional space on the stack each time, until the stack overflows resulting in a segmentation fault.[3]

Very deep recursion[edit]
A recursive function that terminates in theory but causes a call stack buffer overflow in practice can be fixed by transforming the recursion into a loop and storing the function arguments in a stack. This is always possible, because the class of primitive recursive functions is equivalent to the class of LOOP computable functions. Consider the following example in C++-like pseudocode:

A primitive recursive function like the one on the left side can always be transformed into a loop like on the right side.

void function (argument)
{
if (condition)
function (argument.next);


}
stack.push(argument);
while (!stack.empty()) {
argument = stack.pop();
if (condition)
stack.push(argument.next);
}
Very large stack variables[edit]
The other major cause of a stack overflow results from an attempt to allocate more memory on the stack than will fit, for example by creating local array variables that are too large. For this reason some authors recommend that arrays larger than a few kilobytes should be allocated dynamically instead of as a local variable.[4]

An example of a very large stack variable in C:

int foo()
{
double x[1000000];
}
The declared array consumes 8 megabytes of data (assuming each double is 8 bytes); if this is more memory than is available on the stack (as set by thread creation parameters or operating system limits), a stack overflow will occur.

Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to kernel development are usually discouraged from using recursive algorithms or large stack buffers.[5]
.

Kết quả (Việt) 2:

Infinite đệ quy [sửa]
Bài chi tiết: đệ quy Infinite
Nguyên nhân phổ biến nhất của stack overflow là đệ quy quá sâu hoặc vô hạn. Ngôn ngữ như Đề án, trong đó thực hiện tối ưu hóa đuôi-gọi, cho phép đệ quy vô hạn của một cụ thể loại đuôi đệ quy để xảy ra mà không tràn stack. Điều này làm việc bởi vì đuôi-đệ quy các cuộc gọi không mất thêm ngăn xếp không gian [2]. Một ví dụ về đệ quy vô hạn trong C. int foo () { trở lại foo (); } Hàm foo, khi nó được gọi, tiếp tục gọi bản thân , sử dụng thêm không gian trên stack mỗi lần, cho đến khi tràn ngăn xếp kết quả trong một lỗi phân khúc. [3] đệ quy rất sâu [sửa] Một hàm đệ quy mà chấm dứt trong lý thuyết nhưng gây ra một cuộc gọi stack tràn bộ đệm trong thực tế có thể được cố định bằng cách chuyển đổi đệ quy vào một vòng lặp và lưu trữ các đối số chức năng trong một chồng. Đây là luôn luôn có thể, bởi vì lớp các hàm đệ quy nguyên thủy là tương đương với các lớp học của LOOP chức năng tính toán. Hãy xem xét ví dụ sau đây trong C ++ - như giả: . Một hàm đệ quy nguyên thủy như một ở phía bên trái luôn luôn có thể được chuyển đổi thành một vòng lặp như ở phía bên phải void function (đối số) { if (condition) chức năng (argument.next) ; } stack.push (argument); trong khi {(stack.empty ()!) lập luận = stack.pop (); if (điều kiện) stack.push (argument.next); } stack biến rất lớn [sửa] Sự khác nguyên nhân chính của một stack overflow là kết quả của một nỗ lực để cấp phát bộ nhớ hơn trên stack hơn sẽ phù hợp, ví dụ bằng cách tạo ra các biến mảng địa phương quá lớn. Vì lý do này một số tác giả khuyên mảng lớn hơn một vài kilobyte nên được tự động phân bổ thay vì như là một biến địa phương [4]. Một ví dụ của một biến đống rất lớn trong C: int foo () { x đôi [1000000]; } Các mảng được khai báo tiêu thụ 8 megabyte dữ liệu (giả sử mỗi đôi là 8 byte); nếu điều này là bộ nhớ nhiều hơn là có sẵn trên stack (được thiết lập bởi các thông số tạo thread hoặc giới hạn hệ điều hành), một chồng tràn sẽ xảy ra. Ngăn xếp tràn được thực hiện tồi tệ hơn bởi bất cứ điều gì làm giảm kích thước ngăn xếp có hiệu quả của một chương trình nhất định. Ví dụ, cùng một chương trình đang chạy mà không có nhiều đề tài có thể làm việc tốt, nhưng ngay sau khi đa luồng được kích hoạt chương trình sẽ sụp đổ. Điều này là bởi vì hầu hết các chương trình với chủ đề có ít không gian ngăn xếp cho mỗi thread hơn một chương trình không có hỗ trợ luồng. Bởi vì hạt nhân nói chung là đa luồng, người mới để phát triển hạt nhân thường được khuyến khích sử dụng các thuật toán đệ quy hoặc bộ đệm ngăn xếp lớn. [5] .