A colloquial name for a complex block of IP.
The kernel is the most basic part of an operating system. It is a part of software that provides secure access to computer hardware for many applications. This access is limited, and the kernel determines when and how long a program operates on a certain part of the hardware. The classification of cores can be divided into single core, dual core and micro core. Strictly speaking, the kernel is not a necessary part of a computer system.
The kernel is the core of an operating system. It is the first-layer software expansion based on hardware, which provides the most basic functions of the operating system and is the foundation of the operating system. It is responsible for managing the system’s processes, memory, device drivers, files and network systems, and determines the performance and stability.
In modern operating system design, in order to reduce the overhead of the system itself, some modules closely related to the hardware (such as interrupt handlers, device drivers, etc.), basic, common, and high-running frequency modules (such as clock management, Process scheduling, etc.) and key data structures are separated to make them permanent in memory and protect them. This part is usually called the kernel of the operating system.
The program can be directly transferred to the computer for execution. This design shows that the designer does not want to provide any hardware abstraction and operating system support. It is common in the design of early computer systems. Finally, some auxiliary programs, such as program loader and debugger, are designed into the core of the machine, or solidified in read-only memory. When these changes occurred, the concept of the operating system kernel gradually became clear.
The first public version of Linux was version 0.02 in October 1991. Two months later, in December 1991, Linux released version 0.11. This is the first independent kernel that can be used without relying on Minix.
One month after the release of version 0.12, in March, the version number jumped to 0.95, reflecting that the system was becoming mature. Not only that, it was not until two years later, in March 1994, that the milestone 1.0.0 was completed.
From about this time onwards began to use the two-way numbering method to mark the development of kernels, even-numbered kernels
(Such as 1.0, 2.2, 2.4, 2.6) are stable, "product" models, and odd-numbered kernel versions (1.1, 2.3) are cutting-edge or "developing" kernels. A few months after the release of a stable kernel, the development of a new kernel will begin. However, the development of 2.5 did not start until dozens of months after the completion of 2.4.
Most of the discussion in the post-halloween document is the main changes that users need to pay attention to, and the system tools that need to be updated (in order to take advantage of them). Those who care about this information are mainly Linux distributors who want to know in advance what is in the 2.6 kernel, as well as end users, which allows them to determine whether there are programs that need to be upgraded in order to take advantage of the new components.
The KernelJanitors project maintains a list of minor defects that need to be fixed and solutions. Most of these defect solutions are caused by the need to change many parts of the code when applying larger patches to the kernel, for example, some places will affect the device driver. Those who are newly engaged in kernel development can select items in the list at the beginning of their work, so that they can learn how to write kernel code through small projects and have the opportunity to contribute to the community.
Also, in another pre-release project, JohnCherry tracked the errors and warnings found during the compilation of each released kernel version. These compilation statistics have been declining over time, and publishing these results in a systematic form makes the progress achieved at a glance. In many cases, some of these warnings and error messages can be used like the KernelJanitors list, because compilation errors are usually caused by small defects and require some effort to fix.
Finally, there is Andrew Morton's "must-fix" list. Since he has been selected as the maintainer of the 2.6 kernel after the release, he used his privileges to outline the issues that he believes most urgently need to be resolved before the final 2.6 kernel is released. The must-fix list contains the defects in the kernel Bugzilla system, the parts that need to be completed, and other known issues. If these issues are not resolved, it will hinder the 2.6 release. This information can help indicate what steps are needed before the new kernel is released; it can also provide valuable information for those concerned about when the much-anticipated 2.6 kernel release will be completed.
Single core
Monolithic kernel is a very big process. Its interior can be divided into several modules (or levels or other). But at runtime, it is a single big binary image. The communication between the modules is realized by directly calling functions in other modules, rather than message transmission.
The single-kernel structure defines a high-level abstract interface on the hardware. A set of primitives (or system calls) are used to implement the functions of the operating system, such as process management, file system, and storage management. These functions are determined by Multiple modules running in the core state to complete.
Although each module serves these operations individually, the kernel code is highly integrated and difficult to write correctly. Because all modules are running on the same kernel space, a small bug will crash the entire system. However, if the development goes well, the single-core structure can benefit from operating efficiency.
Many modern single-kernel structure kernels, such as Linux and FreeBSD kernels, can call modules into execution at runtime, which can make the expansion of the kernel's functions easier, and can also make the core part of the kernel more concise.
The single-core structure is a very attractive design, because the efficiency of the complexity of the system control code that implements all low-level operations in the same address space will be higher than that in different address spaces. The single-core structure is tending to be easy to design correctly, so its development will be faster than the micro-kernel structure.
An example of a single-kernel structure: the traditional UNIX kernel-such as the version issued by the University of Berkeley, the Linux kernel.
FPGA Spartan Family 5K Gates 238 Cells 166MHz 5V 84-Pin PLCC
Xilinx BGA
FPGA Spartan-3E Family 500K Gates 10476 Cells 572MHz 90nm Technology 1.2V 320-Pin FBGA
FPGA XC5200 Family 16K Gates 1296 Cells 83MHz 0.5um Technology 5V 84-Pin PLCC
FPGA Spartan-IIE Family 50K Gates 1728 Cells 400MHz 0.15um Technology 1.8V 256-Pin FTBGA
Support
