diff --git a/.gitignore b/.gitignore index 0e37430..8596ef1 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,7 @@ *.pdf -/Code/.vs/ -/Code/Debug/ -/Code/x64/ \ No newline at end of file +*/.vs/ +*/.idea/ +*/Debug/ +*/x64/ +*/out/ +*/cmake-build-debug/ \ No newline at end of file diff --git a/CPP-Code/CMakeLists.txt b/CPP-Code/CMakeLists.txt new file mode 100644 index 0000000..a1b57c2 --- /dev/null +++ b/CPP-Code/CMakeLists.txt @@ -0,0 +1,11 @@ +# CMakeList.txt: CPP-Code 的 CMake 项目，在此处包括源代码并定义 +# 项目特定的逻辑。 +# +cmake_minimum_required (VERSION 3.8) + +project ("CPP-Code") + +# 将源代码添加到此项目的可执行文件。 +add_executable (CPP-Code "source/main.cpp") + +# TODO: 如有需要，请添加测试并安装目标。 diff --git a/CPP-Code/CMakeSettings.json b/CPP-Code/CMakeSettings.json new file mode 100644 index 0000000..9204f06 --- /dev/null +++ b/CPP-Code/CMakeSettings.json @@ -0,0 +1,15 @@ +{ + "configurations": [ + { + "name": "x64-Debug", + "generator": "Ninja", + "configurationType": "Debug", + "inheritEnvironments": [ "msvc_x64_x64" ], + "buildRoot": "${projectDir}\\out\\build\\${name}", + "installRoot": "${projectDir}\\out\\install\\${name}", + "cmakeCommandArgs": "", + "buildCommandArgs": "", + "ctestCommandArgs": "" + } + ] +} \ No newline at end of file diff --git a/CPP-Code/head/head.h b/CPP-Code/head/head.h new file mode 100644 index 0000000..3ea11c5 --- /dev/null +++ b/CPP-Code/head/head.h @@ -0,0 +1,8 @@ +// ʼ󳤶 +#define MAXSIZE 5 +// Ĭֵ +#define DEFAULTELEM '0' +// ֵ +#define INFINITY 32767 +// Ĭ +typedef char element_type; diff --git a/CPP-Code/head/link_list.h b/CPP-Code/head/link_list.h new file mode 100644 index 0000000..dfe2430 --- /dev/null +++ b/CPP-Code/head/link_list.h @@ -0,0 +1,161 @@ +#include +#include +#include "head.h" + +// +typedef struct LinkListNode { + element_type data; + struct LinkListNode* next; +} LinkListNode, *LinkList; + +// C޷ֵԱһм +// ʼͷڵ㵥 +int InitLinkListWithHead(LinkList &list) { + list = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (list) { + list->data = NULL; + list->next = nullptr; + return 0; + } + else { + printf("InitLinkListWithHead:ռʧܣ"); + return 1; + } +} + +// ʼͷڵ㵥 +int InitLinkListWithoutHead(LinkList &list) { + list = nullptr; + return 0; +} + +// ͷڵ㵥 +LinkList CreateLinkListWithHead() { + auto list = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (list) { + list->data = NULL; + list->next = nullptr; + } + else { + printf("CreateLinkListWithHead:ռʧܣ"); + } + return list; +} + +// ͷڵ㵥 +LinkList CreateLinkListWithoutHead() { + return nullptr; +} + + +// жͷڵ㵥ǷΪ +int EmptyLinkListWithHead(LinkList list) { + if (list->next) { + return 0; + } + else { + return 1; + } +} + +// жͷڵ㵥ǷΪ +int EmptyLinkListWithoutHead(LinkList list) { + if (list) { + return 0; + } + else { + return 1; + } +} + +// ͷڵ㵥Ԫ +// 0Žڵͷڵ +int InsertLinkListWithHead(LinkList list, int index, element_type elem) { + if (index < 1) { + printf("InsertLinkListWithHead:ֵС\n"); + return 1; + } + // һָpָǰɨ赽Ľ + LinkListNode* p; + // һiʾǰɨ赽Ľ + int i = 0; + // ͷָpΪ0 + p = list; + // ѭָŵĵĽ + // ǵǰһΪŵĽһǿս + while (p->next != NULL && i < index - 1) { + p = p->next; + i++; + } + // ʱiСindex-1ʾ껹ûеӦ + if (i < index - 1) { + printf("InsertLinkListWithHead:ֵ\n"); + return 1; + } + // ʱi==index-1 + LinkListNode* s = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (s) { + s->data = elem; + // pԭĺ̸µĽ + s->next = p->next; + p->next = s; + return 0; + } + else { + printf("InsertLinkListWithHead:ڴʧܣ\n"); + return 1; + } +} + +// ͷڵ㵥Ԫ +// CҲ޷ +int InsertLinkListWithoutHead(LinkList list, int index, element_type elem) { + if (index < 0) { + printf("InsertLinkListWithoutHead:ֵС\n"); + return 1; + } + if (index == 0) { + LinkListNode* s = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (s) { + s->data = elem; + // sĺΪlistָ + s->next = list; + // listָΪsָ + list = s; + return 0; + } + else { + printf("InsertLinkListWithoutHead:ڴʧܣ\n"); + return 1; + } + } + // һָpָǰɨ赽Ľ + LinkListNode* p; + // һiʾǰɨ赽Ľ + int i = 0; + // ͷָpΪ0 + p = list; + // ѭָŵĵĽ + // ǵǰһΪŵĽһǿս + while (p->next != NULL && i < index - 1) { + p = p->next; + i++; + } + // ʱiСindex-1ʾ껹ûеӦ + if (i < index - 1) { + printf("InsertLinkListWithoutHead:ֵ\n"); + return 1; + } + // ʱi==index-1 + LinkListNode* s = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (s) { + s->data = elem; + // pԭĺ̸µĽ + s->next = p->next; + p->next = s; + return 0; + } + else { + printf("InsertLinkListWithoutHead:ռʧܣ\n"); + } +} \ No newline at end of file diff --git a/CPP-Code/head/sequence_list.h b/CPP-Code/head/sequence_list.h new file mode 100644 index 0000000..6f436e3 --- /dev/null +++ b/CPP-Code/head/sequence_list.h @@ -0,0 +1,255 @@ +#include +#include +#include "head.h" + +#pragma warning(disable:6385) +#pragma warning(disable:6386) + +// 顺序表 +class SequenceList { +public: + element_type *data{}; + int length{}; + // 插入函数 + virtual bool Insert(int index, element_type elem); + // 打印函数 + void Printf(); + // 循环插入函数 + bool LoopInsert(element_type *elem, int start, int end); + // 删除函数 + bool Delete(int index, element_type &elem); + // 多个删除函数 + bool MultiDelete(int index, int len, element_type *elem); + // 按位获取元素 + element_type GetElem(int index); + // 按值获取元素 + int Locate(element_type elem); + // 判空 + bool Empty(); + // 销毁 + bool Destroy(); +}; + +// 静态顺序表 +class StaticSequenceList: public SequenceList{ +public: + element_type data[MAXSIZE]{}; + int length; + // 构造函数 + StaticSequenceList(); + // 插入函数 + bool Insert(int index, element_type elem) override; +}; + +// 动态顺序表 +class DynamicSequenceList: public SequenceList{ +public: + // 给一个指针来分配动态数组 + element_type *data; + int length; + // 已分配的最大容量 + int max_size; + // 构造函数 + DynamicSequenceList(); + // 插入函数 + bool Insert(int index, element_type elem) override; + +private: + // 分配其他地址增长动态顺序表的数据空间长度 + bool OtherIncrease(int len); + // 重新分配地址增长动态顺序表的数据空间长度 + bool ReIncrease(int len); +}; + +StaticSequenceList::StaticSequenceList() : SequenceList() { + this->length=0; +} + +DynamicSequenceList::DynamicSequenceList() : SequenceList() { + // 初初始化动态顺序表长度为0 + this->max_size=0; + this->length = 0; + // 申请一片连续的存储空间 + auto* space = (element_type*)malloc(MAXSIZE * sizeof(element_type)); + if (space) { + this->data = space; + this->max_size = MAXSIZE; + } + else { + printf("InitSequenceList:分配空间失败！\n"); + } +} + +void SequenceList::Printf() { + for (int i = 0; i < this->length; i++) { + printf("第%d个元素值为%c\n", i + 1, this->data[i]); + } +} + +bool DynamicSequenceList::OtherIncrease(int len) { + if (len <= 0) { + printf("OtherIncrease:申请空间应该大于0！\n"); + return false; + } + // 申请一片连续的存储空间 + int new_length = this->max_size + len; + auto* space = (element_type*)malloc(new_length * sizeof(element_type)); + if (space) { + // 建立中间变量 + this->data = space; + element_type* temp = this->data; + for (int i = 0; i < this->length; i++) { + this->data[i] = temp[i]; + } + this->max_size = new_length; + free(temp); + return true; + } + else { + printf("OtherIncrease:重新分配空间失败！\n"); + return false; + } +} + +bool DynamicSequenceList::ReIncrease(int len) { + if (len <= 0) { + printf("ReIncrease:申请空间应该大于0！\n"); + return false; + } + // 申请一片连续的存储空间 + int new_length = this->max_size + len; + auto* space = (element_type*)realloc(this->data, new_length * sizeof(element_type)); + if (space) { + this->data = space; + this->max_size += len; + return true; + } + else { + this->max_size = 0; + this->length = 0; + printf("ReIncrease:分配其他地址空间失败！\n"); + return false; + } +} + +bool SequenceList::Insert(int index, element_type elem) { + return false; +} + +bool StaticSequenceList::Insert(int index, element_type elem) { + // 当静态顺序表已经满了就不能插入任何元素 + if (this->length >= MAXSIZE) { + printf("Insert:静态顺序表空间不足，插入失败！\n"); + return false; + } + // 索引位置从0开始，所以可以插入的范围是0到list->length + if (index > this->length || index < 0) { + printf("Insert:插入索引%d超过索引范围！\n", index); + return false; + } + // 从最后一个元素开始交换后移，list->length是空的 + for (int i = this->length; i > index; i--) { + this->data[i] = this->data[i - 1]; + } + this->data[index] = elem; + this->length++; + return true; +} + +bool DynamicSequenceList::Insert(int index, element_type elem) { + if (index > this->length || index < 0) { + printf("Insert:插入索引%d超过索引范围！\n", index); + return false; + } + // 当动态顺序表已经满了，需要新增一个位置 + // 为了避免索引无效而多增加一个空间，所以放在检查索引值的后面 + if (this->length >= MAXSIZE) { + bool result = this->ReIncrease(1); + if (!result) { + printf("Insert:申请空间失败！\n"); + return false; + } + } + for (int i = this->length; i > index; i--) { + this->data[i] = this->data[i - 1]; + } + this->data[index] = elem; + this->length++; + return true; +} + +bool SequenceList::LoopInsert(element_type *elem, int start, int end) { + for (int i = 0; i < end; i++) { + bool result = this->Insert(i, elem[i + start]); + if (!result) { + printf("LoopInsert:循环插入失败！\n"); + return false; + } + } + return true; +} + +bool SequenceList::Delete(int index, element_type &elem) { + if (index >= this->length || index < 0) { + printf("Delete:删除索引超过索引范围！\n"); + return false; + } + elem = this->data[index]; + for (int i = index; i < this->length; i++) { + this->data[i] = this->data[i + 1]; + } + this->length--; + return true; +} + +bool SequenceList::MultiDelete(int index, int len, element_type *elem) { + if (index + len >= this->length || index < 0) { + printf("MultiDelete:删除索引超过索引范围！\n"); + return false; + } + for (int i = index; i < this->length - len; i++) { + if (i < index + len) { + elem[i - index] = this->data[i]; + } + this->data[i] = this->data[i + len]; + } + this->length -= len; + return true; +} + +element_type SequenceList::GetElem(int index) { + if (index >= this->length || index < 0) { + printf("GetElem:查找索引超过索引范围！\n"); + return DEFAULTELEM; + } + return this->data[index]; +} + + +int SequenceList::Locate(element_type elem) { + for (int i = 0; i < this->length; i++) { + if (this->data[i] == elem) { + return i; + } + } + printf("Locate:未能定位到对应值的元素！\n"); + return -1; +} + +bool SequenceList::Empty() { + if (this->length == 0) { + return false; + } + else { + return true; + } +} + +bool SequenceList::Destroy() { + if (this->data) { + free(this->data); + } + delete this; + return true; +} + diff --git a/CPP-Code/source/main.cpp b/CPP-Code/source/main.cpp new file mode 100644 index 0000000..a3674d4 --- /dev/null +++ b/CPP-Code/source/main.cpp @@ -0,0 +1,9 @@ +#include "test.cpp" + + +int main() +{ + SequenceListTest(); +// LinkListTest(); + return 0; +} \ No newline at end of file diff --git a/CPP-Code/source/test.cpp b/CPP-Code/source/test.cpp new file mode 100644 index 0000000..a669ede --- /dev/null +++ b/CPP-Code/source/test.cpp @@ -0,0 +1,46 @@ +// ļ + +#include "../head/sequence_list.h" +#include "../head/link_list.h" + +int SequenceListTest() { + DynamicSequenceList list; + list.Insert(0, 'a'); + element_type a[6] = {'1','2','3','4','5','6'}; + list.LoopInsert(a, 0, 6); + printf("%c", list.data[2]); + /*element_type b[3] = { '9', 'a', 'e' }; + list.LoopInsert(b, 1, 2);*/ + list.Printf(); + //printf("%c", list.data[2]); + /*list.Printf(); + printf("\n"); + int len = 2; + element_type elem[2]; + list.MultiDelete(0, len, elem);*/ + /*list.Printf(); + for (int i = 0; i < len; i++) { + printf("%c\n", elem[i]); + }*/ + /*DynamicSequenceList dlist; + InitDynamicSequenceList(&dlist); + OtherIncreaseDynamicSequenceList(&dlist, 15); + printf("%d", dlist.max_size);*/ + //int index = list.Locate('5'); + //printf("%d", index); + //list.Destroy(); + return 0; +} + +int LinkListTest() { + LinkList list = nullptr; + InitLinkListWithoutHead(list); +// InitLinkListWithHead(list); + //LinkList list = CreateLinkListWithHead(); +// int empty = EmptyLinkListWithHead(list); +// LinkList list = CreateLinkListWithoutHead(); + int empty = EmptyLinkListWithoutHead(list); + printf("%d", empty); + return 0; +} + diff --git a/Operate-System/0-summary-ex.md b/Operate-System/0-summary-ex.md index 3f2ab59..d7e52aa 100644 --- a/Operate-System/0-summary-ex.md +++ b/Operate-System/0-summary-ex.md @@ -2,10 +2,34 @@ ## 基本概念 -### 特征 - ### 功能 +**例题** 系统调用是由操作系统提供给用户的，它()。 + +$A.$直接通过键盘交互方式使用 + +$B.$只能通过用户程序间接使用 + +$C.$是命令接口中的命令 + +$D.$与系统的命令一样 + +解：$B$。系统调用是操作系统为应用程序使用内核功能所提供的接口。 + +**例题** 操作系统与用户通信接口通常不包括()。 + +$A.shell$ + +$B.$命令解释器 + +$C.$广义指令 + +$D.$缓存管理指令 + +解：$D$。广义指令就是系统调用命令，而命令解释器属于命令接口，$shell$是命令解析器，它也属于命令接口。系统中的缓存全部由操作系统管理，对用户是透明的，操作系统不提供管理系统缓存的系统调用。 + +### 特征 + **例题** 单处理机系统中，可并行的是()。 Ⅰ.进程与进程 @@ -24,13 +48,226 @@ $C.$Ⅰ、Ⅲ、Ⅳ $D.$Ⅱ、Ⅲ、Ⅳ -系统调用是由操作系统提供给用户的，它()。 +解：$D$。在单处理机系统（不包含多核的情况）中，同一时刻只能有一个进程占用处理机，因此进程之间不能并行执行。通道是独立于$CPU$的、控制输入/输出的设备，两者可以并行。显然，处理器与设备是可以并行的，难道$CPU$和显示屏不能并行工作？设备与设备是可以并行的，难道显示屏与打印机不能并行工作？ -$A.$直接通过键盘交互方式使用 +**例题** 下列选项中，不属于多道程序设计的基本特征是()。 -$B.$只能通过用户程序间接使用 +$A.$制约性 -$C.$是命令接口中的命令 +$B.$间断性 -$D.$与系统的命令一样 +$C.$顺序性 +$D.$共享性 + +解：$C$。引入多道程序设计后，程序的执行就失去了封闭性和顺序性。程序执行因为共享资源及相互协同的原因产生了竞争，相互制约。考虑到竞争的公平性，程序的执行是断续的。顺序性是单道程序设计的基本特征。 + +## 操作系统类别 + +**例题** 操作系统有多种类型。允许多个用户以交互的方式使用计算机的操作系统，称为()；允许多个用户将若干作业提交给计算机系统集中处理的操作系统，称为()；在()的控制下，计算机系统能及时处理由过程控制反馈的数据，并及时做出响应；在$IBM-PC$中，操作系统称为()。 + +$A.$批处理系统 + +$B.$分时操作系统 + +$C.$实时操作系统 + +$D.$微型计算机操作系统 + +解：$B$、$A$、$C$、$D$。强调交互式方式就是分时操作系统；多个作业集中处理强调了多个，所以就是批处理操作系统；强调及时处理与响应就是实时操作系统。微型计算机操作系统即微机系统，其中$IBM-PC$就是$IBM$发明的$PC$，即个人计算机。 + +### 分时操作系统 + +**例题** 分时系统追求的目标是()。 + +$A.$充分利用$I/O$设备 + +$B.$比较快速响应用户 + +$C.$提高系统吞吐率 + +$D.$充分利用内存 + +解：$B$。正是分时系统的特点同时性、及时性、交互性代表了其目标是快速响应用户，也正是不能完全满足这个目标才出现了实时操作系统。 + +### 实时操作系统 + +**例题** ()不是设计实时操作系统的主要追求目标。 + +$A.$安全可靠 + +$B.$资源利用率 + +$C.$及时响应 + +$D.$快速处理 + +解：$B$。实时性和可靠性是实时操作系统最重要的两个目标，而安全可靠体现了可靠性，快速处理和及时响应体现了实时性。资源利用率不是实时操作系统的主要目标，即为了保证快速处理高优先级任务，允许“浪费”一些系统资源。 + +### 多道程序 + +**例题** 设某计算机系统有一个$CPU$、一台输入设备、一台打印机。现有两个进程同时进入就绪态，且进程$A$先得到$CPU$运行，进程$B$后运行。进程$A$的运行轨迹为：计算$50ms$，打印信息$100ms$，再计算$50ms$，打印信息$100ms$，结束。进程$B$的运行轨迹为：计算$50ms$，输入数据$80ms$，再计算$100ms$，结束。画出它们的时序关系图（可用甘特图)，并说明： + +1）开始运行后，$CPU$有无空闲等待？若有，在哪段时间内等待？计算$CPU$的利用率。 + +2）进程$A$运行时有无等待现象？若有，在何时发生等待现象？ + +3 ）进程$B$运行时有无等待现象？若有，在何时发生等待现象？ + +解：$A$先进入，则先占用设备。后来者等待，得到： + +![甘特图][gantt] + +1）$CPU$在$100\sim150ms$时间段内空闲，利用率为$250/300=83.3\%$。 + +2）进程$A$为无等待现象。 + +3）进程$B$为有等待现象，$0\sim50ms$，$180\sim200ms$。 + +## 操作系统的运行环境 + +**例题** 下列关于系统调用的说法中，正确的是()。 + +Ⅰ.用户程序设计时，使用系统调用命令，该命令经过编译后，形成若干参数和陷入（$trap$）指令 + +Ⅱ.用户程序设计时，使用系统调用命令，该命令经过编译后，形成若干参数和屏蔽中断指令 + +Ⅲ.系统调用功能是操作系统向用户程序提供的接口 + +Ⅳ.用户及其应用程序和应用系统是通过系统调用提供的支持和服务来使用系统资源完成其操作的 + +$A.$Ⅰ、Ⅲ + +$B.$Ⅱ、Ⅳ + +$C.$Ⅰ、Ⅲ、Ⅳ + +$D.$Ⅱ、Ⅲ、Ⅳ + +解：$C$。Ⅰ正确：系统调用需要从用户应用程序调用系统的接口，用户态进入核心态，触发$trap$指令。（如基于$x86$的$Linux$系统，该指令为$int\,Ox80$或$sysenter$。Ⅱ是干扰项，屏蔽中断指令由外部的异步操作造成，由操作系统接收到外部操作而产生对现场进行保护，程序设计无法形成屏蔽中断指令。Ⅲ正确：系统调用的概念。Ⅳ正确：操作系统是一层接口，对上层提供服务，对下层进行抽象。它通过系统调用向其上层的用户、应用程序和应用系统提供对系统资源的使用。 + +**例题** 下列操作系统的各个功能组成部分中，()可不需要硬件的支持。 + +$A.$进程调度 + +$B.$时钟管理 + +$C.$地址映射 + +$D.$中断系统 + +解：$A$。中断系统和地址映射显然都需要硬件支持，因为中断指令和地址映射中的重定位都是离不开硬件支持的。而时钟管理中，重置时钟等是由硬件直接完成的。进程调度由调度算法决定$CPU$使用权,由操作系统实现，无须硬件的支持。 + +**例题** 计算机区分核心态和用户态指令后，从核心态到用户态的转换是由操作系统程序执行后完成的，而用户态到核心态的转换则是由()完成的。 + +$A.$硬件 + +$B.$核心态程序 + +$C.$用户程序 + +$D.$中断处理程序 + +解：$A$。计算机通过硬件中断机制完成由用户态到核心态的转换。$B$显然不正确，核心态程序只有在操作系统进入核心态后才可以执行。$D$中的中断处理程序一般也在核心态执行，在中断完成后对中断的结果进行一系列处理，因此无法完成“转换成核心态”这一任务。若由用户程序将操作系统由用户态转换到核心态，则用户程序中就可使用核心态指令，这就会威胁到计算机的安全，所以$C$不正确。 + +计算机通过硬件完成操作系统由用户态到核心态的转换，这是通过中断机制来实现的。发生中断事件时（有可能是用户程序发出的系统调用），触发中断，硬件中断机制将计算机状态置为核心态。 + +**例题** 在操作系统中，只能在核心态下执行的指令是()。 + +$A.$读时钟 + +$B.$取数 + +$C.$广义指令 + +$D.$寄存器清$0$ + +解：$C$。广义指令即系统调用命令，它必然工作在核心态，所以答案为$C$。要注意区分“调用”和“执行”，广义指令的调用可能发生在用户态，调用广义指令的那条指令不一定是特权指令，但广义指令存在于核心态中，所以执行一定在核心态。 + +**例题** 下列指令中，不能在用户态执行的是()。 + +$A.trap$指令 + +$B.$跳转指令 + +$C.$压栈指令 + +$D.$关中断指令 + +解：$D$。$trap$指令、跳转指令和压栈指令均可以在用户态执行，其中$trap$指令负责由用户态转换为内核态，跳转指令是指改变程序执行顺序的指令，压栈指令即进栈指令，与出栈（弹栈）指令相对，用于将数据压入数据栈。关中断指令为特权指令，指关闭中断机制的指令，必须在核心态才能执行，选$D$。关中断在中断机制中在第一步，用于完整保护现场避免指令打扰，也用于原语执行保持完整，关中断后要执行开中断指令。 + +**例题** 内部异常（内中断）可分为故障（$fault$）、陷阱（$trap$）和终止（$abort$）三类。下列有关内部异常的叙述中，错误的是()。 + +$A.$内部异常的产生与当前执行指令相关 + +$B.$内部异常的检测由$CPU$内部逻辑实现 + +$C.$内部异常的响应发生在指令执行过程中 + +$D.$内部异常处理后返回到发生异常的指令继续执行 + +解：$D$。内部异常由内部产生，即在执行指令出现问题，所以$A$正确。异常由内部$CPU$检测，不必通过外部信号通知$CPU$，所以$B$正确。异常必须立刻响应处理，所以其相应在指令执行过程中，$C$对。对于非法指令等无法通过处理程序修复的问题，必须中断进行，所以不能回到原端点继续执行，$D$错误。 + +**例题** 处理外部中断时，应该由操作系统保存的是()。 + +$A.$程序计数器（$PC$）的内容 + +$B.$通用寄存器的内容 + +$c.$块表（$TLB$）中的内容 + +$D.Cache$中的内容 + +解：$B$。$PC$值由中断隐指令自动保存。通用寄存器内容由操作系统保存。$TLB$称为转译后备缓冲器，与$Cache$一样是$CPU$缓存的一种，都是由各自的缓存器保存。 + +**例题** 假定下列指令已装入指令寄存器，则执行时不可能导致$CPU$从用户态变为内核态（系统态）的是()。 + +$A.DIV\,R0,R1;(R0)/(R1)\rightarrow R0$ + +$B.INT\,n;$产生软中断 + +$C.NOT\,R0;$寄存器$R0$的内容取非 + +$D.MOV\,R0,addr;$把地址$addr$处的内存数据放入寄存器$R0$ + +解：$C$。为什么会产生由用户态转换核心态？因为可能出现异常导致中断。$A$可能除数$R0$为$0$导致异常；$B$由于软中断，所以是一个中断指令，所以会转为核心态；$D$是将内存放入寄存器中，可能产生缺页异常（即放不进去）；$C$是取反，只变一位数字，不会产生异常。 + +**例题** 定时器产生时钟中断后，由时钟中断服务程序更新的部分内容是()。 + +I.内核中时钟变量的值 + +Ⅱ.当前进程占用CPU的时间 + +Ⅲ.当前进程在时间片内的剩余执行时间 + +$A.$仅Ⅰ、Ⅱ + +$B.$仅Ⅱ、Ⅲ + +$C.$仅Ⅰ、Ⅲ + +$D.$Ⅰ、Ⅱ、Ⅱ + +解：$D$。时钟中断的主要工作是处理和时间有关的信息及决定是否执行调度程序。和时间有关的所有信息包括系统时间、进程的时间片、延时、使用$CPU$的时间、各种定时器，因此Ⅰ、Ⅱ、Ⅲ均正确。 + +**例题** 下列关于系统调用的叙述中，正确的是()。 + +Ⅰ.在执行系统调用服务程序的过程中，$CPU$处于内核态 + +Ⅱ.操作系统通过提供系统调用避免用户程序直接访问外设 + +Ⅲ.不同的操作系统为应用程序提供了统一的系统调用接口 + +Ⅳ.系统调用是操作系统内核为应用程序提供服务的接口 + +$A.$仅Ⅰ、Ⅳ + +$B.$仅Ⅱ、Ⅲ + +$C.$仅Ⅰ、Ⅱ、Ⅳ + +$D.$仅Ⅱ、Ⅲ、Ⅳ + +解：$C$。用户可以在用户态调用操作系统的服务，但执行具体的系统调用服务程序是处于内核态的，Ⅰ正确；设备管理属于操作系统的职能之一，包括对输入/输出设备的分配、初始化、维护等，用户程序需要通过系统调用使用操作系统的设备管理服务，Ⅱ正确；操作系统不同，底层逻辑、实现方式均不相同，为应用程序提供的系统调用接口也不同，Ⅲ错误；系统调用是用户在程序中调用操作系统提供的子功能，Ⅳ正确。 + +[gantt]:data:image/png;base64,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 \ No newline at end of file diff --git a/Operate-System/0-summary.md b/Operate-System/0-summary.md index 6268b6d..c1c0758 100644 --- a/Operate-System/0-summary.md +++ b/Operate-System/0-summary.md @@ -124,6 +124,10 @@ ### 单道批处理系统 + 引入脱机输入/输出技术（磁带），并用监督程序复杂控制作业的输入输出。 ++ 特点： + + 自动性。 + + 顺序性。 + + 单道性。 + 优点： + 缓解了一定的人机速度矛盾，资源利用率得到提升。 + 缺点： @@ -133,11 +137,21 @@ ### 多道批处理系统 + 操作系统正式诞生，引入中断技术，从而能并发执行程序。 ++ 特点： + + 多道。 + + 宏观并行。 + + 微观串行。 + 优点： + 多道程序并发执行，共享计算机资源。 + 资源利用率提升，$CPU$和其他资源基本上忙碌，系统吞吐量增大。 + 缺点： - + 用户响应时间长，无法人机交互，不能控制作业执行。 + + 用户响应时间长。 + + 无法人机交互，不能控制作业执行。 ++ 问题： + + 处理器分配。 + + 多道程序内存分配。 + + $I/O$设备分配。 + + 程序数据组织存放。 ## 操作系统的分类 @@ -146,15 +160,23 @@ ### 分时操作系统 + 计算机以时间片为单位轮流为各个用户/作业服务，每个用户可以通过终端与计算机交互。 ++ 特点： + + 同时性。 + + 交互性。 + + 独立性。 + + 及时性。 + 优点： + 用户请求可以及时响应，解决人机交互问题。 - + 运行多个用户共同使用一台计算机，且用户对计算机的操作哦相互独立，感受不到其他人存在。 + + 运行多个用户共同使用一台计算机，且用户对计算机的操作相互独立，感受不到其他人存在。 + 缺点： + 不能处理紧急任务，操作系统对于每个用户都是公平的，循环给出时间片。 ### 实时操作系统 + 能优先响应紧急任务，不用等待时间片排队。 ++ 特点： + + 及时性。 + + 可靠性。 + 优点： + 能优先处理紧急任务，使用率更高。 + 对于紧急事件能有效高速处理，可靠性较高。 @@ -164,40 +186,45 @@ ### 其他操作系统 -+ 网络操作系统：伴随计算机网络发展而但是，能连接网络中各个计算机从而能传输数据，实现网络中各种资源的共享和计算机之间的通信，如Windows NT。 ++ 网络操作系统：伴随计算机网络发展而但是，能连接网络中各个计算机从而能传输数据，实现网络中各种资源的共享和计算机之间的通信，如$Windows\,NT$。 + 分布式操作系统：具有分布性和并行性，系统中各个计算机地位相同，任何工作可以分布在这些计算机上，并行写协同完成任务。 -+ 个人计算机操作系统：方便个人使用的操作系统，如Windows 10、MacOS。 ++ 个人计算机操作系统：方便个人使用的操作系统，如$Windows\,10$、$MacOS$。 -## 操作系统的运行机制 +## 操作系统的运行环境 -### 两种指令 +### 操作系统的运行机制 + +#### 两种指令 + 指令就是处理器能识别和执行的最基本命令。所以指令能控制处理器，需要给指令进行控制，对于危险的指令要更高的权限。 + 特权指令： + 指具有特殊权限的指令，只用于操作系统或其他系统软件，一般不直接提供给用户使用。 - + 如有关对I/O设备使用的指令、有关访问程序状态的指令、存取特殊寄存器指令。 - + 具体而言如清内存、置时钟、分配系统资源、修改虚存的段表和页表，修改用户的访问权限等。 + + 如有关对$I/O$设备使用的指令、有关访问程序状态的指令、存取特殊寄存器指令。 + + 具体而言如清内存、置时钟、输入输出、分配系统资源、修改虚存的段表和页表，修改用户的访问权限等。 + 非特权指令： + 可以被用户自由使用的指令。 - + 如读取时钟、从内存中取数、将运算结果装入内存、算术运算等。 + + 如读取时钟、从内存中取数、将运算结果装入内存、算术运算、寄存器清零等。 -### 两种处理器状态 ++ 置时钟：若在用户态下执行“置时钟指令”，则一个用户进程可在时间片还未到之前把时钟改回去，从而导致时间片永远不会用完，进而导致该用户进程一直占用$CPU$，这显然不合理。 ++ 输入输出：涉及中断指令，而中断处理由系统内核负责，工作在核心态。 + +#### 两种处理器状态 操作系统根据处理器状态来判断是否可以使用特权指令。 -操作系统用程序状态字寄存器PSW中的某标志位来标识当前处理器处于什么状态，如0为用户态，1为核心态。 +操作系统用程序状态字寄存器$PSW$中的某标志位来标识当前处理器处于什么状态，如$0$为用户态，$1$为核心态。 + 用户态（目态）：只能执行非特权指令。 + 核心态（管态）：可以执行特权指令。 -### 两种程序 +#### 两种程序 根据程序所可以使用指令的权限，程序分为两种： + 内核程序：是系统的管理者，既可以运行特权指令也可以运行非特权指令，运行在核心态。 + 应用程序：为了保证安全，普通应用程序只能执行非特权指令，运行在用户态。 -## 操作系统的内核 +#### 操作系统的内核 操作系统的程序既然分为内核程序和应用程序，就说明有些程序是更重要的。 @@ -205,14 +232,106 @@ 内核功能分为： -+ 时钟管理：进程等的计时功能。 -+ 中断处理：负责实现中断机制。 -+ 原语：是一种特殊的程序，是最接近硬件的部分，这种程序的运行具有原子性，运行时间短，调用次数频繁，如设备驱动、$CPU$切换等。 ++ 时钟管理： + + 进程等的计时功能。 + + 时钟中断实现进程切换。 ++ 中断处理： + + 负责实现中断机制，提高$CPU$利用率。 + + 只有一小部分功能属于内核，负责保护和恢复现场，转移控制权道相关处理程序。 ++ 原语： + + 是一种特殊的公用程序，是最接近硬件的部分。 + + 这种程序的运行具有原子性，运行时间短，调用次数频繁。 + + 定义原语的直接方法是关闭中断，让所有操作一致完成再打开中断。 + + 如设备驱动、$CPU$切换、进程通信等。 + 系统资源管理功能：可能包含在内核中也可能不包含： + 进程管理。 + 存储器管理。 + 设备管理。 +### 中断 + +中断是内核所必要的基本功能。 + +#### 中断机制的概念 + ++ 并发批处理就需要中断机制。发生中断就表示需要操作系统介入，开展管理工作。 ++ 用户态道核心态之间的转换是通过中断实现的，且是唯一的途径，通过硬件的控制，类似$10$标志位。 ++ 而核心态道用户态之间的切换只用执行一个特权指令，将程序状态字$PSW$的标志位设置为用户态。 + +1. 当中断发生时，$CPU$立刻进入核心态。 +2. 当中断发生后，当前运行的进程暂停，并由操作系统内核对中断进行处理。 +3. 对于不同的中断信号会进行不同的处理。 + +#### 中断的分类 + ++ 内中断（异常、例外、陷入）信号来自$CPU$内部，与当前执行的命令有关，必须立刻处理，且对于无法恢复故障的需要终止进程。 + + 自愿中断：指令中断。如系统调用时使用的访管指令（陷入指令、$trap$指令）引起的**访管中断**。 + + 强迫中断： + + 硬件故障。（缺页） + + 软件中断。（整数除$0$） ++ 外中断（中断）信号来自$CPU$外部，与当前执行的命令无关。 + + 外设请求：如$I/O$操作完成时发出的中断信号。 + + 时钟中断：时间片已到。 + + 人工干预。 + +另一种分类方式内中断分为： + ++ 陷阱、陷入。 ++ 故障。 ++ 终止。 + +#### 外中断的处理过程 + +1. 关中断。$CPU$响应中断后，首先要保护程序的现场状态，在保护现场的过程中，$CPU$不应响应更高级中断源的中断请求。否则，若现场保存不完整，在中断服务程序结束后，也就不能正确地恢复并继续执行现行程序。 +2. 保存断点。为保证中断服务程序执行完毕后能正确地返回到原来的程序，必须将原来的程序的断点（即程序计数器$PC$）保存起来。 +3. 中断服务程序寻址。其实质是取出中断服务程序的入口地址送入程序计数器$PC$。 +4. 保存现场和屏蔽字。进入中断服务程序后，首先要保存现场，现场信息一般是指程序状态字寄存器PSWR和某些通用寄存器的内容。 +5. 开中断。允许更高级中断请求得到响应。 +6. 执行中断服务程序。这是中断请求的目的。 +7. 关中断。保证在恢复现场和屏蔽字时不被中断。 +8. 恢复现场和屏蔽字。将现场和屏蔽字恢复到原来的状态。 +9. 开中断、中断返回。中断服务程序的最后一条指令通常是一条中断返回指令，使其返回到原程序的断点处，以便继续执行原程序。 + +第一步道第三步是$CPU$进入中断周期后，由硬件自动完成（中断隐指令），第四到九条是中断服务程序完成。 + +### 系统调用 + +#### 系统调用的概念 + +系统调用是程序接口的组成部分，用于应用软件调用，也称为广义指令。可以认为是一种可供应应用程序调用的特殊函数，应用程序可以发出系统调用请求来获得操作系统的服务。 + +#### 系统调用的过程 + +为什么要使用系统调用来处理应用程序的请求？如果不同进程争用有限的资源，没有良好的处理机制就会混乱。所以操作系统提供系统调用提供统一处理的过程规范，应用程序通过系统调用发出请求，操作系统在根据请求协调管理。 + +系统调用本质就是指令中断，所以需要特权指令，从而系统调用的相关处理只能在**核心态**下进行。 + +1. 传递系统调用参数。 +2. 执行陷入指令（用户态）。 +3. 执行系统调用相应服务程序（核心态）。 +4. 返回用户程序。 + ++ 陷入指令也称为访管指令，在用户态执行（因此不是特权指令），执行陷入指令后立刻引发一个内中断，从而$CPU$进入核心态。 ++ 发出系统调用请求的是在用户态，而对系统调用的相应处理在核心态下进行。 ++ 陷入指令是**唯一一个**只能在用户态执行，而不能核心态执行的指令。 + +#### 系统调用的类别 + ++ 设备管理：设备的请求、释放、启动。 ++ 文件管理：文件的读、写、创建、删除。 ++ 进程管理：进程的创建、撤销、阻塞、唤醒。 ++ 进程通信：进程之间的消息传递、信号传递。 ++ 内存管理：内存的分配、回收。 + +#### 系统调用与库函数的区别 + +层次|使用关系 +:--:|:-----: +普通应用程序|可直接使用系统调用，也可以使用库函数。有的库函数涉及系统调用有些则不涉及 +编程语言|向上提供库函数，有时会将系统调用封装为库函数以隐藏系统调用细节，从而使上层系统调用更方便 +操作系统|向上提供系统调用 +裸机|无 + ## 操作系统的体系结构 体系结构根据内核功能的多少分为： @@ -223,79 +342,3 @@ + 大内核：除了基本功能外还包含进程管理等其他功能。 + 优点：高性能。 + 缺点：内核代码庞大，结构混乱，难以维护。 - -## 中断 - -中断是内核所必要的基本功能。 - -### 中断机制的概念 - -+ 并发批处理就需要中断机制。发生中断就表示需要操作系统介入，开展管理工作。 -+ 用户态道核心态之间的转换是通过中断实现的，且是唯一的途径。 -+ 而核心态道用户态之间的切换只用执行一个特权指令，将程序状态字PSW的标志位设置为用户态。 - -1. 当中断发生时，$CPU$立刻进入核心态。 -2. 当中断发生后，当前运行的进程暂停，并由操作系统内核对中断进行处理。 -3. 对于不同的中断信号会进行不同的处理。 - -### 中断的分类 - -+ 内中断（异常、例外、陷入）信号来自$CPU$内部，与当前执行的命令有关。 - + 自愿中断：指令中断。如系统调用时使用的访管指令（陷入指令、trap指令） - + 强迫中断： - + 硬件故障。（缺页） - + 软件中断。（整数除0） -+ 外中断（中断）信号来自$CPU$外部，与当前执行的命令无关。 - + 外设请求。（I/O操作完成时发出的中断信号） - + 人工干预。 - -另一种分类方式内中断分为： - -+ 陷阱、陷入。 -+ 故障。 -+ 终止。 - -### 外中断的处理过程 - -1. 执行外每个指令后，$CPU$都要检查当前是否有外部中断信号。 -2. 若检测到外部中断信号，则需要保护呗中断进程的$CPU$环境（如程序状态字PSW、程序计数器PC、各种通用寄存器）。 -3. 根据中断信号类型转入相应的中断处理程序。 -4. 恢复原进程的$CPU$环境并退出中断，返回原进程继续往下执行。 - -## 系统调用 - -### 系统调用的概念 - -系统调用是程序接口的组成部分，用于应用软件调用，也称为广义指令。可以任务是一种可供应应用程序调用的特殊函数，应用程序可以发出系统调用请求来获得操作系统的服务。 - -### 系统调用的过程 - -为什么要使用系统调用来处理应用程序的请求？如果不同进程争用有限的资源，没有良好的处理机制就会混乱。所以操作系统提供系统调用提供统一处理的过程规范，应用程序通过系统调用发出请求，操作系统在根据请求协调管理。 - -系统调用本质就是指令中断，所以需要特权指令，从而系统调用的相关处理只能在**核心态**下进行。 - -1. 传递系统调用参数。 -2. 执行陷入指令（用户态）。 -3. 执行系统调用相应服务程序（核心态）。 -4. 返回用户程序。 - -+ 陷入指令在用户态执行，执行陷入指令后立刻引发一个内中断，从而$CPU$进入核心态。 -+ 发出系统调用请求的是在用户态，而对系统调用的相应处理在核心态下进行。 -+ 陷入指令是**唯一一个**只能在用户态执行，而不能核心态执行的指令。 - -### 系统调用的类别 - -+ 设备管理：设备的请求、释放、启动。 -+ 文件管理：文件的读、写、创建、删除。 -+ 进程管理：进程的创建、撤销、阻塞、唤醒。 -+ 进程通信：进程之间的消息传递、信号传递。 -+ 内存管理：内存的分配、回收。 - -### 系统调用与库函数的区别 - -层次|使用关系 -:--:|:-----: -普通应用程序|可直接使用系统调用，也可以使用库函数。有的库函数涉及系统调用有些则不涉及 -编程语言|向上提供库函数，有时会将系统调用封装为库函数以隐藏系统调用细节，从而使上层系统调用更方便 -操作系统|向上提供系统调用 -裸机|无