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) 1:

Vô hạn đệ quy [sửa]Bài chi tiết: vô hạn đệ quyNguyên nhân phổ biến nhất của ngăn xếp tràn là quá sâu hoặc vô hạn đệ quy. Ngôn ngữ như đề án, mà thực hiện cuộc gọi đuôi tối ưu hóa, cho phép các đệ quy vô hạn của một loại cụ thể-đệ quy đuôi — xảy ra mà không ngăn xếp tràn. Công trình này bởi vì đệ quy đuôi cuộc gọi không mất không gian bổ sung ngăn xếp.[2]Một ví dụ về các đệ 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 riêng của mình, bằng cách sử dụng không gian bổ sung vào ngăn xếp mỗi lần, cho đến khi ngăn xếp tràn dẫn đến một lỗi phân khúc.[3]Rất sâu đệ quy [sửa]Một chức năng đệ quy mà chấm dứt trong lý thuyết nhưng gây ra một lỗi tràn bộ đệm gọi ngăn xếp 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 ngăn xếp. Điều này luôn luôn có thể, bởi vì lớp nguyên thủy đệ quy chức năng là tương đương với các lớp học chức năng computable LOOP. Hãy xem xét ví dụ sau trong C++ giống như mã giả:Một chức năng đệ quy nguyên thủy như một bên trái có thể luôn luôn được chuyển vào một vòng lặp như ở phía bên phải.vô hiệu chức năng (đối số) { Nếu (điều kiện) chức năng (argument.next); }stack.Push(argument);trong khi (! stack.empty()) {} đối số = stack.pop(); Nếu (điều kiện) stack.Push(argument.Next);}Rất lớn ngăn xếp biến [sửa]Nguyên nhân chính của một ngăn xếp tràn kết quả từ một nỗ lực để cấp phát bộ nhớ thêm vào ngăn xếp hơn sẽ phù hợp, ví dụ bằng cách tạo ra các biến địa phương mảng quá lớn. Vì lý do này, một số tác giả đề nghị rằng mảng lớn hơn một vài kilobyte nên được cấp phát động thay vì như là một biến địa phương.[4]Một ví dụ về một biến rất lớn ngăn xếp trong C:int foo() { đôi x [1000000];}Các mảng tuyên bố tiêu thụ 8 MB 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 ngăn xếp (như được trình bày bởi chủ đề tạo ra tham số hoặc giới hạn hệ điều hành), một ngăn xếp 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ì mà làm giảm kích thước ngăn xếp hiệu quả của một chương trình. Ví dụ, cùng một chương trình đang được chạy mà không có nhiều chủ đề có thể làm việc tốt, nhưng càng sớm càng đ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 chủ đề hơn một chương trình không có hỗ trợ luồng. Vì hạt nhân được thường đa luồng, mọi người mới để phát triển hạt nhân được thường khuyến khích sử dụng thuật toán đệ quy hoặc lớn ngăn xếp bộ đệm.[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, mọi 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]