精华内容
下载资源
问答
  • 操作系统内存管理实验(C语言实现)
  • 运行成功,比较基础,登录后,对文件进行创建,删除,打开,关闭,读取,写入,保存,打印当前文件功能
  • 介绍linux下开发基础知识,有很详细的代码实例,很适合初学者
  • 一个用C语言编写的关于操作系统里存储器管理固定分区顺序分配算法
  • 操作系统 中分页式存储管理算法的源代码 C语言编写
  • C语言,运行成功,比较基础,c语言模拟设计一个有N个进程运行的进程调度程序,用最高优先数优先法:在创建进程时,给定一个进程优先数,并按一定规则减少优先数,直至所有进程运行完成(例如进程每获得一次cpu进程数...
  • c语言,运行成功,比较基础,模拟存储管理(页面调度),页面淘汰算法采用先进先出(FIFO)
  • c语言,运行成功,比较基础,单道批处理系统作业调度模拟程序:采用先来先服务(FCFS),最短作业优先(SJF)和响应比高者优先(HRN)三种作业调度算法
  • typedef struct node { char name[10]; int span;//轮转时间 int take;//占用时间 int used;//已用的时间 int need;//还需要的时间 char status;//状态 struct node *next; }PCB;
  • 操作系统实验c语言

    千次阅读 2019-12-07 20:38:23
    这个学期学了操作系统,实验课是用c语言实现几个操作系统比较核心的算法,其实也只是模拟一下,照真实的操作系统所运行的程序,还差得太远,虽然很想接触硬件,接触底层,用汇编等实现一下操作系统,但要真正实现一...

    这个学期学了操作系统,实验课是用c语言实现几个操作系统比较核心的算法,其实也只是模拟一下,照真实的操作系统所运行的程序,还差得太远,虽然很想接触硬件,接触底层,用汇编等实现一下操作系统,但要真正实现一个操作系统,需要付出的太多,也怕耽误了学业,有兴趣的可以去看看《30天自制操作系统》。
    下面是我整理的用c语言实现的操作系统用到的几个算法
    操作系统实验一(进程调度算法)
    操作系统实验二(银行家算法)
    操作系统实验三(动态分区分配算法)
    操作系统实验四(页面置换算法)

    展开全文
  • c语言编写的代码。模拟的操作系统进程调度的小实验。学习操作系统课程时,为了加强对进程调度算法的理解而做的小实验。
  • C语言实现银行家算法,操作系统实验报告,附带源码与实验截图
  • c语言 操作系统 请求分页 OPT FIFO LRU算法 源码
  • C语言实现:短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块( PCB)表示。进程控制块可以包含如下信息:进程名、到达时间、需要运行时间、已用CPU时间、进程...
  • 假设要求从系统中输入N个需访问的柱面号,当前磁头的移动方向由键盘输入(1代表磁头从外往内移动,-1代表磁头由内往外移动),当前磁头刚完成访问序号为M的柱面,请编程输出采用电梯调度算法得到的柱面访问序列号,...
  • C语言操作系统——页面置换算法(FIFO/LRU)

    万次阅读 多人点赞 2018-06-03 21:42:44
    由于本学期学习操作系统所以需要用代码实现一些算法,本人大二由于对C语言掌握的不太好,所以一直逼着自己用C语言写代码,还好写出来了,在这里与大家分享。首先建立一个工程文件,本人喜欢建立一个头文件,一个功能...

    由于本学期学习操作系统所以需要用代码实现一些算法,本人大二由于对C语言掌握的不太好,所以一直逼着自己用C语言写代码,还好写出来了,在这里与大家分享。

    首先建立一个工程文件,本人喜欢建立一个头文件,一个功能文件和一个主函数文件。

    头文件,page_replace.h

    #include <stdio.h>
    #include <windows.h>


    typedef struct Page
    {
    int num;//固定每一行
    int mark;//几次换页未使用的次数
    }Page;


    void FIFO(int input[],int sum,int count);//先进先出置换算法
    void LRU(int input[],int sum,int count);//最久未使用置换算法



    功能文件,page_replace.cpp

    #include "page_replace.h"
    #define MAX 20


    void FIFO(int input[],int sum,int count)//先进先出置换算法
    {
    printf("\n____________FIFO算法_____________\n");
    int sub=0;//substitution置换次数
    Page frame[MAX];//页帧(物理块可以放的页数)
    for(int i=0;i<sum;i++)//将几个页放到空白物理块中
    {
    frame[i].num=input[i]; 
            //sub++; 
    printf("%d",frame[i].num);
    printf(" | ");
    for(int j=0;j<=i;j++)
    printf("%d ",frame[j].num);
    Sleep(500);
    printf("\n");
    }
    for(i=sum;i<count;i++)
    {
    int j;
    for(j=0;j<sum;j++)
    {
    if(input[i]==frame[j].num)//在物理块中找到需要的页
    {
    printf("%d\n",input[i]);
    Sleep(500);
    break;
    }
    }
    if(j==sum)//在当前物理块中没有匹配的页
    {
    sub++;
    frame[(sub-1)%sum].num=input[i];//换掉最旧的页
    printf("%d",input[i]);
    printf(" | ");
    for(int k=0;k<sum;k++)
    printf("%d ",frame[k].num);//打印最新的物理块中的页
    Sleep(500);
    printf("\n");
    }
    }
    printf("FIFO算法页面置换的次数为:%d\n\n",sub);
    }


    void LRU(int input[],int sum,int count)//最久未使用置换算法
    {
    printf("____________LRU算法_____________\n");
    int sub=0;
    Page frame[MAX];
    for(int i=0;i<sum;i++)//将几个页放到空白物理块中
    {
    frame[i].num=input[i]; 
    printf("%d",frame[i].num);
    printf(" | ");
    for(int j=0;j<=i;j++)
    printf("%d ",frame[j].num);
    Sleep(500);
    printf("\n");
    }
    for(i=sum;i<count;i++)
    {
    int j;
    for(j=0;j<sum;j++)
    {
    if(input[i]==frame[j].num)
    {
    printf("%d\n",input[i]);
    Sleep(500);
    break;
    }
    }
    if(j==sum)//在当前物理块中没有找到合适的页
    {
    sub++;
    for(j=0;j<sum;j++)
    {
    frame[j].mark=0;//初始化
    for(int k=0;k<=i;k++)//向前遍历,找到最近最少使用的 
    {
    if(frame[j].num==input[k])
    frame[j].mark=k;//会被最近使用的一次给覆盖掉,记录一个页面是第几次换页使用的,k为下标,如果k越小说明最近很少使用
    }
    }
    for(int d=0;d<sum;d++)
    {
    int x=0;
    for(j=0;j<sum;j++)
    {
    if(frame[d].mark<=frame[j].mark)//求最小的数
    x++ ;
    }
    if(x==sum)
    {
    frame[d].num=input[i];
    break;
    }


    }
    printf("%d",input[i]);
    printf(" | ");
    for(int k=0;k<sum;k++)
    printf("%d ",frame[k].num);
    Sleep(500);
    printf("\n");
    }
    }
    printf("LRU算法页面置换的次数为:%d\n",sub);

    }

    主函数文件,page_replace_test.cpp

    #include "page_replace.h"
    #define MAX 50


    void main()
    {
    printf("_____________页面置换算法______________\n");
    int sum=0;//物理块数
    int input[MAX];//输入的0-9数字串流
    char ch;
    int flag=1;
    int i=0;
    printf("请输入物理块数(正整数):\n");
    scanf("%d",&sum);
    printf("请输入0-9的数字代表页面号,以#结束:\n");
    while(flag)
    {
    scanf("%c",&ch);
    if(ch!='#' && ch!='\n')
    {
    input[i]=(int)ch-48;
    i++;
    }
    else if(ch=='#')
    flag=0;
    }
    int count=i;//记录页面个数
    FIFO(input,sum,count);
    LRU(input,sum,count);
    }

    代码到此结束,最后的运行结果是这样子滴得意

    谢谢大家观看,后续还会有分享。

    展开全文
  • 我以前看一本书,名叫 30天自制操作系统;大概翻了一下,感觉也不是太难;因为比如,它有一整章在讲,C语言指针、C语言画一...首先一个,不能用写应用程序的C语言去写一个操作系统;因为C本身很多功能依赖于操作系统...

        我以前看一本书,名叫 30天自制操作系统;大概翻了一下,感觉也不是太难;因为比如,它有一整章在讲,C语言指针、C语言画一个矩形;你要是熟悉C语言的话,指针肯定理解;在没有窗口的情况下,用Turbo C 2.0画一个矩形也不是什么难事;
        后来有一天准备照书实践一下,仔细看了一下,原来问题不是一般的多;首先一个,不能用写应用程序的C语言去写一个操作系统;因为C本身很多功能依赖于操作系统,你去写一个操作系统的时候这个时候还没有操作系统,像C最常用的printf函数这个时候是不能用的;如果硬要运行此类C功能,会导致保护性错误,CPU罢工。
        原作者的意思是,不管你用C或C++来写一个操作系统,如果你不能理解C或C++是如何转换为汇编语言的,你是无法写出一个操作系统的;他肯定是对的。
        原来原作者是自己从gcc改装了一个C编译器来,然后还附带了一堆工具;才能把代码构建为可运行的操作系统代码。
        下面按原书附带的工具,来构建它的第一个C程序;他提供的编译器名为cc1.exe;就是把他提供的东西拷贝到一个单独的目录执行了看;
        
        一共有6个步骤把一个C语言程序构建为操作系统可用的代码;
       1 使用cc1.exe从bootpack.c生成bootpack.gas;
       2 使用gas2nask.exe从bootpack.gas生成bootpack.nas;
       3 使用nask.exe从bootpack.nas生成bootpack.obj;
       4 使用obi2bim.exe从bootpack.obj生成bootpack.bim;
       5 使用bim2hrb.exe从bootpack.bim生成bootpack.hrb;
        到此做成了机器语言;那么书中的汇编程序是nasm语法的;
       然后使用copy命令将asmhead.bin与bootpack.hrb结合起来,做成haribote.sys;

     

    步骤1

    cc1.exe没有帮助的,但它应该是gcc的语法;操作了几次,把.gas做出来;.gas就是汇编代码了;

    步骤2,生成.nas;

    步骤3,生成.obj;

    拷过来它的一个工具,执行一步操作;到此没有错;

    步骤4,生成.bim;

    一直出错;此步要链接一些C库;是在原书附带的光盘;

    把这些C头文件和库拷到操作的临时目录;还是不能构建出.bim文件;它还有一个规则文件.rul;

    到此就不能执行;必须按作者提供的光盘内容的目录结构,以及makefile文件,才能构建代码;自己拷工具和代码文件到单独目录构建的话需要自己写makefile和规则文件;下回再搞;

    展开全文
  • 一个操作系统原型系统的实现 (实现操作系统的3个主要功能:进程管理、内存(存储)管理、文件管理)
  • C语言模拟操作系统中内存页面置换中先进先出(FIFO) 在red hat中调试可以运行的
  • 使用c语言写的简易版的实时操作系统,主要使用双链表的原理实现,我个人觉得可以促进对个人成长。代码好理解又不好理解,是我推敲好久后写好的成品,如果有需要可以下载
  • 利用C语言绘制操作系统图像界面

    万次阅读 多人点赞 2016-09-13 11:39:04
    那么怎么表现C语言的强大功能呢,如果还只是一味的在界面上输出几行字符,那太没意思,考虑到,我们的目标是做出像windows那样具备舒心的图像用户界面那样的系统,所以在这一节,我们由字符模式切换入画面模式,初步...

    阅读博客的朋友可以参看视频:
    Linux kernel Hacker, 从零构建自己的内核

    有了C语言这一利器后,不多多拿来用,那就太对不起前面的一系列努力了。那么怎么表现C语言的强大功能呢,如果还只是一味的在界面上输出几行字符,那太没意思,考虑到,我们的目标是做出像windows那样具备舒心的图像用户界面那样的系统,所以在这一节,我们由字符模式切换入画面模式,初步体验下,那些绚丽多彩的图像界面是如何发展而成的。

    要想由字符模式转入图形模式,我们需要操作硬件,特别是向显卡发送命令,让其进入图形显示模式,就如同前面我们所做的,要操作硬件,一般需要使用BIOS调用,以下几行就是打开VGA显卡色彩功能的代码:

    mov  al, 0x13h
    mov  ah, 0x00
    int  0x10

    其中al 的值决定了要设置显卡的色彩模式,下面是一些常用的模式设置:
    1. 0x03, 16色字符模式
    2. 0x12, VGA图形模式, 640 * 480 * 4位彩色模式,独特的4面存储模式
    3. 0x13, VGA图形模式, 320 * 200 * 8位彩色模式,调色板模式
    4. 0x6a, 扩展VGA图形模式, 800 * 600 * 4彩色模式

    我们采用的是0x13模式,其中320*200*8 中,最后的数值8表示的是色彩值得位数,也就是我们可以用8位数值表示色彩,总共可以显示256种色彩。

    系统显存的地址是0x000a0000,当我们执行上面几句代码后,望显存地址写入数据,那么屏幕就会出现相应的变化了。

    我们先看看内核的汇编代码部分(kernel.asm):

    %include "pm.inc"
    
    org   0x9000
    
    jmp   LABEL_BEGIN
    
    [SECTION .gdt]
     ;                                  段基址          段界限                属性
    LABEL_GDT:          Descriptor        0,            0,                   0  
    LABEL_DESC_CODE32:  Descriptor        0,      SegCode32Len - 1,       DA_C + DA_32
    LABEL_DESC_VIDEO:   Descriptor        0B8000h,         0ffffh,            DA_DRW
    LABEL_DESC_VRAM:    Descriptor        0,         0ffffffffh,            DA_DRW
    LABEL_DESC_STACK:   Descriptor        0,             TopOfStack,        DA_DRWA+DA_32
    
    GdtLen     equ    $ - LABEL_GDT
    GdtPtr     dw     GdtLen - 1
               dd     0
    
    SelectorCode32    equ   LABEL_DESC_CODE32 -  LABEL_GDT
    SelectorVideo     equ   LABEL_DESC_VIDEO  -  LABEL_GDT
    SelectorStack     equ   LABEL_DESC_STACK  -  LABEL_GDT
    SelectorVram      equ   LABEL_DESC_VRAM   -  LABEL_GDT
    
    
    [SECTION  .s16]
    [BITS  16]
    LABEL_BEGIN:
         mov   ax, cs
         mov   ds, ax
         mov   es, ax
         mov   ss, ax
         mov   sp, 0100h
    
         mov   al, 0x13
         mov   ah, 0
         int   0x10
    
         xor   eax, eax
         mov   ax,  cs
         shl   eax, 4
         add   eax, LABEL_SEG_CODE32
         mov   word [LABEL_DESC_CODE32 + 2], ax
         shr   eax, 16
         mov   byte [LABEL_DESC_CODE32 + 4], al
         mov   byte [LABEL_DESC_CODE32 + 7], ah
    
         ;set stack for C language
         xor   eax, eax
         mov   ax,  cs
         shl   eax, 4
         add   eax, LABEL_STACK
         mov   word [LABEL_DESC_STACK + 2], ax
         shr   eax, 16
         mov   byte [LABEL_DESC_STACK + 4], al
         mov   byte [LABEL_DESC_STACK + 7], ah
    
         xor   eax, eax
         mov   ax, ds
         shl   eax, 4
         add   eax,  LABEL_GDT
         mov   dword  [GdtPtr + 2], eax
    
         lgdt  [GdtPtr]
    
         cli   ;关中断
    
         in    al,  92h
         or    al,  00000010b
         out   92h, al
    
         mov   eax, cr0
         or    eax , 1
         mov   cr0, eax
    
         jmp   dword  SelectorCode32: 0
    
         [SECTION .s32]
         [BITS  32]
         LABEL_SEG_CODE32:
         ;initialize stack for c code
         mov  ax, SelectorStack
         mov  ss, ax
         mov  esp, TopOfStack
    
         mov  ax, SelectorVram
         mov  ds,  ax
    
    C_CODE_ENTRY:
         %include "write_vga.asm"
    
    
         io_hlt:  ;void io_hlt(void);
          HLT
          RET
    
    SegCode32Len   equ  $ - LABEL_SEG_CODE32
    
    [SECTION .gs]
    ALIGN 32
    [BITS 32]
    LABEL_STACK:
    times 512  db 0
    TopOfStack  equ  $ - LABEL_STACK

    解释下上面代码,我们设置了一个描述符,LABEL_DESC_VRAM, 这个描述符对应的内存起始地址是0,长度是0xffffffff,也就是我们把整个4G内存当做一段可读可写的内存,有了这个设置后,我们在C语言里就可以随意读写内存的任何地方。

    LABEL_DESC_STACK 这个描述符用来设置一段可读可写的内存,它的起始地址是LABEL_STACK, 可以看到,程序通过语句:times 512 db 0
    初始化了512字节的内存。C语言的运行,特别是函数调用时,是需要一个堆栈来传递参数的,所以,要运行C语言,我们首先需要为其配置一个堆栈,该描述符所对应的这512自己内存就是给C语言使用的,由于堆栈只有512字节,在后面我们使用C语言写的代码中,函数的局部变量大小不能超过512字节,例如下面的代码可能就要出错了:

    void fun() {
      char buf[513];
    }

    语句%include write_vga.asm”, 表明,我们要开发的C代码文件叫write_vga.c, 我们写完C代码后,会使用上一节的步骤将它编译成汇编,然后include到我们当前的汇编文件里,统一编译成可执行内核。

    最后一小块代码:
    io_hlt: ;void io_hlt(void);
    HLT
    RET
    作用是进入死循环,HLT指令会让系统进入休眠状态。

    导入C语言

    硬件,堆栈等基层设施通过汇编准备就绪后,我们可以使用C语言开发图形功能了。显示器的每一个像素对应一个点,一个点可以显示256种不同的颜色,因此,只要我们给每个点设置成相应的颜色,那么最终就可以绘制出特定的图像。

    我们看看如何用C语言写入显存从而操作屏幕图像,write_ram.c:

    void CMain(void) {
        int i;
        char*p = 0;
    
        for (i = 0xa0000; i <= 0xaffff; i++) {
            p = i;
            *p = i & 0x0f;  
        }
    
        for(;;) {
           io_hlt();
        }
    
    }
    

    代码中,我们将指针P指向地址0xa0000, 这个地址正好就是vga显存地址,vga显存地址从0xa0000开始,直到0xaffff结束,总共64k.接着语句:
    *p = i & 0x0f 将一个数值写入显存,这个值可以是0-256中任意一个数值,我们代码里是将i的最后4位作为像素颜色写入显存,这个值是任意的,大家可以随意设置。

    在Ubuntu中写出上面代码后,通过命令编译成二进制文件:
    gcc -m32 -fno-asynchronous-unwind-tables -s -c -o write_vga.asm write_vga.c

    于是在目录下会生成write_vga.o二进制文件,接着使用objconv进行反汇编:
    ./objconv -fnasm write_vga.asm write_vga.o
    反汇编后代码如下:

    ; Disassembly of file: write_vga.o
    ; Tue Sep 13 10:30:14 2016
    ; Mode: 32 bits
    ; Syntax: YASM/NASM
    ; Instruction set: 80386
    
    
    global CMain: function
    
    extern io_hlt                                           ; near
    
    
    SECTION .text   align=1 execute                         ; section number 1, code
    
    CMain:  ; Function begin
            push    ebp                                     ; 0000 _ 55
            mov     ebp, esp                                ; 0001 _ 89. E5
            sub     esp, 24                                 ; 0003 _ 83. EC, 18
            mov     dword [ebp-0CH], 0                      ; 0006 _ C7. 45, F4, 00000000
            mov     dword [ebp-10H], 655360                 ; 000D _ C7. 45, F0, 000A0000
            jmp     ?_002                                   ; 0014 _ EB, 17
    
    ?_001:  mov     eax, dword [ebp-10H]                    ; 0016 _ 8B. 45, F0
            mov     dword [ebp-0CH], eax                    ; 0019 _ 89. 45, F4
            mov     eax, dword [ebp-10H]                    ; 001C _ 8B. 45, F0
            and     eax, 0FH                                ; 001F _ 83. E0, 0F
            mov     edx, eax                                ; 0022 _ 89. C2
            mov     eax, dword [ebp-0CH]                    ; 0024 _ 8B. 45, F4
            mov     byte [eax], dl                          ; 0027 _ 88. 10
            add     dword [ebp-10H], 1                      ; 0029 _ 83. 45, F0, 01
    ?_002:  cmp     dword [ebp-10H], 720895                 ; 002D _ 81. 7D, F0, 000AFFFF
            jle     ?_001                                   ; 0034 _ 7E, E0
    ?_003:  call    io_hlt                                  ; 0036 _ E8, FFFFFFFC(rel)
            jmp     ?_003                                   ; 003B _ EB, F9
    ; CMain End of function
    
    
    SECTION .data   align=1 noexecute                       ; section number 2, data
    
    
    SECTION .bss    align=1 noexecute                       ; section number 3, bss
    

    在上面代码中去掉以section 开始的指令,这些指令会影响我们把当前汇编结合入内核kerne.asm.
    同时去掉开头的两句:

    global CMain: function
    extern io_hlt

    因为我们要把两个汇编文件结合成一个,所以这两句声明是多余的。做完这些后,再用nasm编译kernel.asm:
    nasm -o kernel.bat kernel.asm
    于是本地目录下,内核文件就编译好了。

    接着运行java工程,生成虚拟软盘,运行结果如下:
    这里写图片描述

    大家注意看,kernel.bat写入了两个扇区,也就是说,我们内核的大小已经超过了512字节。此时我们需要修改一下内核加载器,让内核加载器一次读入两个扇区才能把内核完全加载入内存,打开boot.asm,将readFloppy中的:
    mov ah, 0x02
    mov al, 1
    改成:
    mov al, 2
    也就是一次读取两个扇区的内容,修改后再次编译boot.asm:
    nasm -o boot.bat boot.asm

    最后再次运行java程序,此时生成的虚拟软盘中,才会包含完整的内核文件。启动虚拟机,加载虚拟软盘后,运行情况如下:
    这里写图片描述

    大家可以看到,屏幕显示出了条纹状图像。

    本节所以代码均可在网易云课堂上下载:
    Linux kernel Hacker, 从零构建自己的内核

    展开全文
  • 操作系统进程管理实验(C语言实现)
  • 了解文件管理系统的作用和工作方式 了解FAT文件系统的结构 学习文件管理系统的一般开发方法 2 需求说明 2.1 基本要求 设计并实现一个目录列表函数(无须支持选项如ls -a、la -l等),用来显示当前...
  • 用C-Free5软件写的,主函数为Int类型。在其他软件上可能要改成void,算法方面没有什么问题。如果要缓冲池满就把生产者M1的数改的比消费者M2的高,要缓冲池空则相反。
  • 操作系统银行家算法,C语言。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 题一:银行家算法 题二:可变分区存储管理系统模拟 题三:进程调度算法 题四:页面调度算法 c语言版 带设计框图和注释 结果截图 含文档及.cpp文件

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382,009
精华内容 152,803
关键字:

c语言操作系统

c语言 订阅