清华大学《操作系统》- 在线课堂精品课程
├─{1}--第零讲 在线教学环境准备
│├─{1}--0.1 在线实验平台
││ #1.1.1#--平台使用说明.pdf
││
│└─{2}--0.2 课件PPT下载
│ #1.2.1#--课件PPT下载.pdf
│ (1.2.1)--操作系统课件2.zip
│ (1.2.2)--操作系统课件1.zip
│
├─{2}--第一讲 操作系统概述
│├─{1}--1.1 课程概述
││ --视频.mp4
││ --视频.srt
││
│├─{2}--1.2 教学安排
││ --视频.mp4
││ --视频.srt
││
│├─{3}--1.3 什么是操作系统
││ --1.3 什么是操作系统.mp4
││ --1.3 什么是操作系统.srt
││
│├─{4}--1.4 为什么学习操作系统，如何学习操作系统
││ --1.4 为什么学习操作系统，如何学习操作系统.mp4
││ --1.4 为什么学习操作系统，如何学习操作系统.srt
││
│├─{5}--1.5 操作系统实例
││ --视频.mp4
││ --视频.srt
││
│├─{6}--1.6 操作系统的演变
││ --视频.mp4
││ --视频.srt
││
│└─{7}--1.7 操作系统结构
│ --视频.mp4
│ --视频.srt
│
├─{3}--第二讲 实验零 操作系统实验环境准备
│├─{1}--2.1 前言和国内外现状
││ --2.1 前言和国内外现状.mp4
││ --2.1 前言和国内外现状.srt
││
│├─{2}--2.2 OS实验目标
││ --2.2 OS实验目标.mp4
││ --2.2 OS实验目标.srt
││
│├─{3}--2.3 8个OS实验概述
││ --2.3 8个OS实验概述.mp4
││ --2.3 8个OS实验概述.srt
││
│├─{4}--2.4 实验环境搭建
││ #3.4.1#--2.4 实验环境搭建.pdf
││ --2.4 实验环境搭建.mp4
││ --2.4 实验环境搭建.srt
││
│├─{5}--2.5 x86-32硬件介绍
││ --2.5 x86-32硬件介绍.mp4
││ --2.5 x86-32硬件介绍.srt
││
│├─{6}--2.6 ucore部分编程技巧
││ --2.6 ucore部分编程技巧.mp4
││ --2.6 ucore部分编程技巧.srt
││
│└─{7}--2.7 演示实验操作过程
│ #3.7.1#--Q6.pdf
│ #3.7.2#--Q7.pdf
│ #3.7.3#--Q10.pdf
│ --2.7 演示实验操作过程.mp4
│ --2.7 演示实验操作过程.srt
│
├─{4}--第三讲 启动、中断、异常和系统调用
│├─{1}--3.1 BIOS
││ --3.1 BIOS.mp4
││ --3.1 BIOS.srt
││
│├─{2}--3.2 系统启动流程
││ --3.2 系统启动流程.mp4
││ --3.2 系统启动流程.srt
││
│├─{3}--3.3 中断、异常和系统调用比较
││ --3.3 中断、异常和系统调用比较.mp4
││ --3.3 中断、异常和系统调用比较.srt
││
│├─{4}--3.4 系统调用
││ --3.4 系统调用.mp4
││ --3.4 系统调用.srt
││
│├─{5}--3.5 系统调用示例
││ --3.5 系统调用示例.mp4
││ --3.5 系统调用示例.srt
││
│└─{6}--3.6 ucore+系统调用代码
│ --3.6 ucore+系统调用代码.mp4
│ --3.6 ucore+系统调用代码.srt
│
├─{5}--第四讲 实验一 bootloader启动ucore os
│├─{1}--4.1 启动顺序
││ --4.1 启动顺序.mp4
││ --4.1 启动顺序.srt
││
│├─{2}--4.2 C函数调用的实现
││ --4.2 C函数调用的实现.mp4
││ --4.2 C函数调用的实现.srt
││
│├─{3}--4.3 GCC内联汇编
││ --4.3 GCC内联汇编.mp4
││ --4.3 GCC内联汇编.srt
││
│├─{4}--4.4 x86中断处理过程
││ --4.4 x86中断处理过程.mp4
││ --4.4 x86中断处理过程.srt
││
│├─{5}--4.5 练习一
││ --4.5 练习一.mp4
││ --4.5 练习一.srt
││
│├─{6}--4.6 练习二
││ --4.6 练习二.mp4
││ --4.6 练习二.srt
││
│├─{7}--4.7 练习三
││ --4.7 练习三.mp4
││ --4.7 练习三.srt
││
│├─{8}--4.8 练习四 练习五
││ --4.8 练习四练习五.mp4
││ --4.8 练习四练习五.srt
││
│└─{9}--4.9 练习六
│ --4.9 练习六.mp4
│ --4.9 练习六.srt
│
├─{6}--第五讲 物理内存管理 连续内存分配
│├─{1}--5.1 计算机体系结构和内存层次
││ --5.1 计算机体系结构和内存层次.mp4
││ --5.1 计算机体系结构和内存层次.srt
││
│├─{2}--5.2 地址空间和地址生成
││ --5.2 地址空间和地址生成.mp4
││ --5.2 地址空间和地址生成.srt
││
│├─{3}--5.3 连续内存分配
││ --5.3 连续内存分配.mp4
││ --5.3 连续内存分配.srt
││
│├─{4}--5.4 碎片整理
││ --5.4 碎片整理.mp4
││ --5.4 碎片整理.srt
││
│└─{5}--5.5 伙伴系统
│ --5.5 伙伴系统.mp4
│ --5.5 伙伴系统.srt
│
├─{7}--第六讲 物理内存管理 非连续内存分配
│├─{1}--6.1 非连续内存分配的需求背景
││ --6.1 非连续内存分配的需求背景.mp4
││ --6.1 非连续内存分配的需求背景.srt
││
│├─{2}--6.2 段式存储管理
││ --6.2 段式存储管理.mp4
││ --6.2 段式存储管理.srt
││
│├─{3}--6.3 页式存储管理
││ --6.3 页式存储管理.mp4
││ --6.3 页式存储管理.srt
││
│├─{4}--6.4 页表概述
││ --6.4 页表概述.mp4
││ --6.4 页表概述.srt
││
│├─{5}--6.5 快表和多级页表
││ --6.5 快表和多级页表.mp4
││ --6.5 快表和多级页表.srt
││
│├─{6}--6.6 反置页表
││ --6.6 反置页表.mp4
││ --6.6 反置页表.srt
││
│└─{7}--6.7 段页式存储管理
│ --6.7 段页式存储管理.mp4
│ --6.7 段页式存储管理.srt
│
├─{8}--第七讲 实验二 物理内存管理
│├─{1}--7.1 了解x86保护模式中的特权级
││ --7.1 了解x86保护模式中的特权级.mp4
││ --7.1 了解x86保护模式中的特权级.srt
││
│├─{2}--7.2 了解特权级切换过程
││ --7.2 了解特权级切换过程.mp4
││ --7.2 了解特权级切换过程.srt
││
│├─{3}--7.3 了解段页表
││ --7.3 了解段页表.mp4
││ --7.3 了解段页表.srt
││
│├─{4}--7.4 了解UCORE建立段页表
││ --7.4 了解ucore建立段页表.mp4
││ --7.4 了解ucore建立段页表.srt
││
│└─{5}--7.5 演示lab2实验环节
│ --7.5 演示lab2实验环节.mp4
│ --7.5 演示lab2实验环节.srt
│
├─{9}--第八讲 虚拟存储概念
│ ├─{1}--8.1 虚拟存储的需求背景
│ │ --8.1 虚拟存储的需求背景.mp4
│ │ --8.1 虚拟存储的需求背景.srt
│ │
│ ├─{2}--8.2 覆盖和交换
│ │ --8.2 覆盖和交换.mp4
│ │ --8.2 覆盖和交换.srt
│ │
│ ├─{3}--8.3 局部性原理
│ │ --8.3 局部性原理.mp4
│ │ --8.3 局部性原理.srt
│ │
│ ├─{4}--8.4 虚拟存储概念
│ │ --8.4 虚拟存储概念.mp4
│ │ --8.4 虚拟存储概念.srt
│ │
│ ├─{5}--8.5 虚拟页式存储
│ │ --8.5 虚拟页式存储.mp4
│ │ --8.5 虚拟页式存储.srt
│ │
│ └─{6}--8.6 缺页异常
│ --8.6 缺页异常.mp4
│ --8.6 缺页异常.srt
│
├─{10}--第九讲 页面置换算法
│├─{1}--9.1 页面置换算法的概念
││ --9.1 页面置换算法的概念.mp4
││ --9.1 页面置换算法的概念.srt
││
│├─{2}--9.2 最优算法、先进先出算法和最近最久未使用算法
││ --9.2 最优算法、先进先出算法和最近最久未使用算法.mp4
││ --9.2 最优算法、先进先出算法和最近最久未使用算法.srt
││
│├─{3}--9.3 时钟置换算法和最不常用算法
││ --9.3 时钟置换算法和最不常用算法.mp4
││ --9.3 时钟置换算法和最不常用算法.srt
││
│├─{4}--9.4 Belady现象和局部置换算法比较
││ --9.4 Belady现象和局部置换算法比较.mp4
││ --9.4 Belady现象和局部置换算法比较.srt
││
│├─{5}--9.5 工作集置换算法
││ --9.5 工作集置换算法.mp4
││ --9.5 工作集置换算法.srt
││
│├─{6}--9.6 缺页率置换算法
││ --9.6 缺页率置换算法.mp4
││ --9.6 缺页率置换算法.srt
││
│└─{7}--9.7 抖动和负载控制
│ --9.7 抖动和负载控制.mp4
│ --9.7 抖动和负载控制.srt
│
├─{11}--第十讲 实验三 虚拟内存管理
│├─{1}--10.1 实验目标：虚存管理
││ --10.1 实验目标：虚存管理.mp4
││ --10.1 实验目标：虚存管理.srt
││
│├─{2}--10.2 回顾历史和了解当下
││ --10.2 回顾历史和了解当下.mp4
││ --10.2 回顾历史和了解当下.srt
││
│├─{3}--10.3 处理流程、关键数据结构和功能
││ --10.3 处理流程、关键数据结构和功能.mp4
││ --10.3 处理流程、关键数据结构和功能.srt
││
│├─{4}--10.4 页访问异常
││ --10.4 页访问异常.mp4
││ --10.4 页访问异常.srt
││
│└─{5}--10.5 页换入换出机制
│ --10.5 页换入换出机制.mp4
│ --10.5 页换入换出机制.srt
│
├─{12}--第十一讲 进程和线程
│├─{1}--11.1 进程的概念
││ --11.1 进程的概念.mp4
││ --11.1 进程的概念.srt
││
│├─{2}--11.2 进程控制块
││ --11.2 进程控制块.mp4
││ --11.2 进程控制块.srt
││
│├─{3}--11.3 进程状态
││ --11.3 进程状态.mp4
││ --11.3 进程状态.srt
││
│├─{4}--11.4 三状态进程模型
││ --11.4 三状态进程模型.mp4
││ --11.4 三状态进程模型.srt
││
│├─{5}--11.5 挂起进程模型
││ --11.5 挂起进程模型.mp4
││ --11.5 挂起进程模型.srt
││
│├─{6}--11.6 线程的概念
││ --11.6 线程的概念.mp4
││ --11.6 线程的概念.srt
││
│├─{7}--11.7 用户线程
││ --11.7 用户线程.mp4
││ --11.7 用户线程.srt
││
│└─{8}--11.8 内核线程
│ --11.8 内核线程.mp4
│ --11.8 内核线程.srt
│
├─{13}--第十二讲 进程控制
│├─{1}--12.1 进程切换
││ --12.1 进程切换.mp4
││ --12.1 进程切换.srt
││
│├─{2}--12.2 进程创建
││ --12.2 进程创建.mp4
││ --12.2 进程创建.srt
││
│├─{3}--12.3 进程加载
││ --12.3 进程加载.mp4
││ --12.3 进程加载.srt
││
│└─{4}--12.4 进程等待与退出
│ --12.4 进程等待与退出.mp4
│ --12.4 进程等待与退出.srt
│
├─{14}--第十三讲 实验四 内核线程管理
│├─{1}--13.1 总体介绍
││ --13.1 总体介绍.mp4
││ --13.1 总体介绍.srt
││
│├─{2}--13.2 关键数据结构
││ --13.2 关键数据结构.mp4
││ --13.2 关键数据结构.srt
││
│├─{3}--13.3 执行流程
││ --13.3 执行流程.mp4
││ --13.3 执行流程.srt
││
│└─{4}--13.4 实际操作
│ --13.4 实际操作.mp4
│ --13.4 实际操作.srt
│
├─{15}--第十四讲 实验五 用户进程管理
│├─{1}--14.1 总体介绍
││ --14.1 总体介绍.mp4
││ --14.1 总体介绍.srt
││
│├─{2}--14.2 进程的内存布局
││ --14.2 进程的内存布局.mp4
││ --14.2 进程的内存布局.srt
││
│├─{3}--14.3 执行ELF格式的二进制代码-do_execve的实现
││ --14.3 执行ELF格式的二进制代码-do_execve的实现.mp4
││ --14.3 执行ELF格式的二进制代码-do_execve的实现.srt
││
│├─{4}--14.4 执行ELF格式的二进制代码-load_icode的实现
││ --14.4 执行ELF格式的二进制代码-load_icode的实现.mp4
││ --14.4 执行ELF格式的二进制代码-load_icode的实现.srt
││
│├─{5}--14.5 进程复制
││ --14.5 进程复制.mp4
││ --14.5 进程复制.srt
││
│└─{6}--14.6 内存管理的copy-on-write机制
│ --14.6 内存管理的copy-on-write机制.mp4
│ --14.6 内存管理的copy-on-write机制.srt
│
├─{16}--第十五讲 处理机调度
│├─{1}--15.1 处理机调度概念
││ --15.1 处理机调度概念.mp4
││ --15.1 处理机调度概念.srt
││
│├─{2}--15.2 调度准则
││ --15.2 调度准则.mp4
││ --15.2 调度准则.srt
││
│├─{3}--15.3 先来先服务、短进程优先和最高响应比优先调度算法
││ --15.3 先来先服务、短进程优先和最高响应比优先调度算法.mp4
││ --15.3 先来先服务、短进程优先和最高响应比优先调度算法.srt
││
│├─{4}--15.4 时间片轮转、多级反馈队列、公平共享调度算法和ucore
││ --15.4 时间片轮转、多级反馈队列、公平共享调度算法和ucore.mp4
││ --15.4 时间片轮转、多级反馈队列、公平共享调度算法和ucore.srt
││
│├─{5}--15.5 实时调度和多处理器调度
││ --15.5 实时调度和多处理器调度.mp4
││ --15.5 实时调度和多处理器调度.srt
││
│└─{6}--15.6 优先级反置
│ --15.6 优先级反置.mp4
│ --15.6 优先级反置.srt
│
├─{17}--第十六讲 实验六 调度器
│├─{1}--16.1 总体介绍和调度过程
││ --16.1 总体介绍和调度过程.mp4
││ --16.1 总体介绍和调度过程.srt
││
│├─{2}--16.2 调度算法支撑框架
││ --16.2 调度算法支撑框架.mp4
││ --16.2 调度算法支撑框架.srt
││
│├─{3}--16.3 时间片轮转调度算法
││ --16.3 时间片轮转调度算法.mp4
││ --16.3 时间片轮转调度算法.srt
││
│└─{4}--16.4 Stride调度算法
│ --16.4 Stride调度算法.mp4
│ --16.4 Stride调度算法.srt
│
├─{18}--第十七讲 同步互斥
│├─{1}--17.1 背景
││ --17.1 背景.mp4
││ --17.1 背景.srt
││
│├─{2}--17.2 现实生活中的同步问题
││ --17.2 现实生活中的同步问题.mp4
││ --17.2 现实生活中的同步问题.srt
││
│├─{3}--17.3 临界区和禁用硬件中断同步方法
││ --17.3 临界区和禁用硬件中断同步方法.mp4
││ --17.3 临界区和禁用硬件中断同步方法.srt
││
│├─{4}--17.4 基于软件的同步方法
││ --17.4 基于软件的同步方法.mp4
││ --17.4 基于软件的同步方法.srt
││
│└─{5}--17.5 高级抽象的同步方法
│ --17.5 高级抽象的同步方法.mp4
│ --17.5 高级抽象的同步方法.srt
│
├─{19}--第十八讲 信号量与管程
│├─{1}--18.1 信号量
││ --18.1 信号量.mp4
││ --18.1 信号量.srt
││
│├─{2}--18.2 信号量使用
││ --18.2 信号量使用.mp4
││ --18.2 信号量使用.srt
││
│├─{3}--18.3 管程
││ --18.3 管程.mp4
││ --18.3 管程.srt
││
│├─{4}--18.4 哲学家就餐问题
││ --18.4 哲学家就餐问题.mp4
││ --18.4 哲学家就餐问题.srt
││
│└─{5}--18.5 读者-写者问题
│ --18.5 读者-写者问题.mp4
│ --18.5 读者-写者问题.srt
│
├─{20}--第十九讲 实验七 同步互斥
│├─{1}--19.1 总体介绍
││ --19.1 总体介绍.mp4
││ --19.1 总体介绍.srt
││
│├─{2}--19.2 底层支撑
││ --19.2 底层支撑.mp4
││ --19.2 底层支撑.srt
││
│├─{3}--19.3 信号量设计实现
││ --19.3 信号量设计实现.mp4
││ --19.3 信号量设计实现.srt
││
│├─{4}--19.4 管程和条件变量设计实现
││ --19.4 管程和条件变量设计实现.mp4
││ --19.4 管程和条件变量设计实现.srt
││
│└─{5}--19.5 哲学家就餐问题
│ --19.5 哲学家就餐问题.mp4
│ --19.5 哲学家就餐问题.srt
│
├─{21}--第二十讲 死锁和进程通信
│├─{1}--20.1 死锁概念
││ --20.1 死锁概念.mp4
││ --20.1 死锁概念.srt
││
│├─{2}--20.2 死锁处理方法
││ --20.2 死锁处理方法.mp4
││ --20.2 死锁处理方法.srt
││
│├─{3}--20.3 银行家算法
││ --20.3 银行家算法.mp4
││ --20.3 银行家算法.srt
││
│├─{4}--20.4 死锁检测
││ --20.4 死锁检测.mp4
││ --20.4 死锁检测.srt
││
│├─{5}--20.5 进程通信概念
││ --20.5 进程通信概念.mp4
││ --20.5 进程通信概念.srt
││
│├─{6}--20.6 信号和管道
││ --20.6 信号和管道.mp4
││ --20.6 信号和管道.srt
││
│└─{7}--20.7 消息队列和共享内存
│ --20.7 消息队列和共享内存.mp4
│ --20.7 消息队列和共享内存.srt
│
├─{22}--第二十一讲 文件系统
│├─{1}--21.1 文件系统和文件
││ --21.1 文件系统和文件.mp4
││ --21.1 文件系统和文件.srt
││
│├─{2}--21.2 文件描述符
││ --21.2 文件描述符.mp4
││ --21.2 文件描述符.srt
││
│├─{3}--21.3 目录、文件别名和文件系统种类
││ --21.3 目录、文件别名和文件系统种类.mp4
││ --21.3 目录、文件别名和文件系统种类.srt
││
│├─{4}--21.4 虚拟文件系统
││ --21.4 虚拟文件系统.mp4
││ --21.4 虚拟文件系统.srt
││
│├─{5}--21.5 文件缓存和打开文件
││ --21.5 文件缓存和打开文件.mp4
││ --21.5 文件缓存和打开文件.srt
││
│├─{6}--21.6 文件分配
││ --21.6 文件分配.mp4
││ --21.6 文件分配.srt
││
│└─{7}--21.7 空闲空间管理和冗余磁盘阵列RAID
│ --21.7 空闲空间管理和冗余磁盘阵列RAID.mp4
│ --21.7 空闲空间管理和冗余磁盘阵列RAID.srt
│
├─{23}--第二十二讲 实验八 文件系统
│├─{1}--22.1 总体介绍
││ --22.1 总体介绍.mp4
││ --22.1 总体介绍.srt
││
│├─{2}--22.2 ucore 文件系统架构
││ --22.2 ucore 文件系统架构.mp4
││ --22.2 ucore 文件系统架构.srt
││
│├─{3}--22.3 Simple File System分析
││ --22.3 Simple File System分析.mp4
││ --22.3 Simple File System分析.srt
││
│├─{4}--22.4 Virtual File System分析
││ --22.4 Virtual File System分析.mp4
││ --22.4 Virtual File System分析.srt
││
│├─{5}--22.5 IO设备接口分析
││ --22.5 IO设备接口分析.mp4
││ --22.5 IO设备接口分析.srt
││
│└─{6}--22.6 执行流程分析
│ --22.6 执行流程分析.mp4
│ --22.6 执行流程分析.srt
│
├─{24}--第二十三讲 IO子系统
│├─{1}--23.1 IO特点
││ --23.1 IO特点.mp4
││ --23.1 IO特点.srt
││
│├─{2}--23.2 IO结构
││ --23.2 IO结构.mp4
││ --23.2 IO结构.srt
││
│├─{3}--23.3 IO数据传输
││ --23.3 IO数据传输.mp4
││ --23.3 IO数据传输.srt
││
│├─{4}--23.4 磁盘调度
││ --23.4 磁盘调度.mp4
││ --23.4 磁盘调度.srt
││
│└─{5}--23.5 磁盘缓存
│ --23.5 磁盘缓存.mp4
│ --23.5 磁盘缓存.srt
│
**** Hidden Message *****
啥也不说了，感谢楼主分享哇！ 啥也不说了，感谢楼主分享哇！ 啥也不说了，感谢楼主分享哇！ 么有分，谁能送我点积分啊::>_<:: 啥也不说了，感谢楼主分享哇！ 啥也不说了，感谢楼主分享哇！ 啥也不说了，感谢楼主分享哇！ 啥也不说了，感谢楼主分享哇！ 确实是难得好帖啊，顶先
页:
[1]
2