<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[robin97的专栏]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/robin97</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; robin97]]></copyright><item><title><![CDATA[Lenix多任务演示]]></title><link>https://blog.csdn.net/robin97/article/details/7169624</link><guid>https://blog.csdn.net/robin97/article/details/7169624</guid><author>robin97</author><pubDate>Sat, 31 Dec 2011 22:53:27 +0800</pubDate><description><![CDATA[#include 
#include 

#define USER_APP_STACK              512

byte_t                      app_stack1[USER_APP_STACK];
byte_t                      app_stack2[USER_APP_STACK];
byte_t]]></description><category></category></item><item><title><![CDATA[进程调度(草稿）]]></title><link>https://blog.csdn.net/robin97/article/details/7087273</link><guid>https://blog.csdn.net/robin97/article/details/7087273</guid><author>robin97</author><pubDate>Wed, 21 Dec 2011 09:06:24 +0800</pubDate><description><![CDATA[进程调度的起因。
这是由于多道程序设计出现后，才出现的问题。在单任务操作系统中，并不存在进程调度。也就是说只有在多任务的操作系统中才会出现进程调度的问题。这是由于系统中同时存在多个处于运行态的进程，而系统中并不能保证为每个进程分配一个CPU，这个时候就要有选择性的确定哪些进程可以运行。
进程调度需要考虑的问题。
1、进程的重要性。负责处理重要工作的进程，需要获得更多的运行机会，甚至于在工作完]]></description><category></category></item><item><title><![CDATA[Lenix固定长度内存分配源代码分析（草稿）]]></title><link>https://blog.csdn.net/robin97/article/details/7089306</link><guid>https://blog.csdn.net/robin97/article/details/7089306</guid><author>robin97</author><pubDate>Wed, 21 Dec 2011 08:58:09 +0800</pubDate><description><![CDATA[Lenix在给定的内存块中划分出两个部分
1、内存块对象区域。这部分用来将内存块构造成一个单向链表。这个属于管理空间，属于消耗空间。这个结构由于对象与存储空间分离，因此在存储空间出现了写越界，并不会造成管理结构的崩溃，可以保证系统正常运行。
2、内存块区域。实际可分配的空间
这里形成一个对应关系，可以从内存地址计算出内存块对象的地址。
在分配的时候，只需要从空闲队列中取出一个内存块，并返回]]></description><category></category></item><item><title><![CDATA[内存管理（草稿）]]></title><link>https://blog.csdn.net/robin97/article/details/7088792</link><guid>https://blog.csdn.net/robin97/article/details/7088792</guid><author>robin97</author><pubDate>Wed, 21 Dec 2011 08:57:54 +0800</pubDate><description><![CDATA[内存管理是为了有效地利用内存。
最理想的情况是，需要使用的内存都提前分配好，这样就省略了内存管理这一步，简化了工作，也能提高程序的运行效率。但实际上这是不可能的，从硬件角度来说，程序运行的硬件环境可能不同，配置的内存不同。从软件角度来说，所需要的内存可能远远大于物理内存。这就决定了不可能提前分配好所有的内存。从利用率来看，提前分配好所有内存是一个极大的浪费。
内存的分配实际上是在一块较大的、连]]></description><category></category></item><item><title><![CDATA[通过关中断的方式来实现原语的分析]]></title><link>https://blog.csdn.net/robin97/article/details/7082948</link><guid>https://blog.csdn.net/robin97/article/details/7082948</guid><author>robin97</author><pubDate>Mon, 19 Dec 2011 09:40:56 +0800</pubDate><description><![CDATA[原语是指几个（2个及以上）连续执行，同时不能被打断的操作。
打断这些连续的操作，有两种可能。一种是主动的，一种是被动的。
主动的打断是指程序主动进入睡眠，而出现的操作中断。
被动是指在操作期间发生外部中断，CPU转去响应中断，而在中断处理过程中，有可能使高优先级的进程进入运行态，如果是抢占式内核，就会导致任务切换，也就形成了操作中断。例如在执行过程中，硬盘操作完成，发出中断，硬盘的中断处理程]]></description><category></category></item><item><title><![CDATA[Proc_sleep源代码分析]]></title><link>https://blog.csdn.net/robin97/article/details/7081767</link><guid>https://blog.csdn.net/robin97/article/details/7081767</guid><author>robin97</author><pubDate>Sun, 18 Dec 2011 16:48:56 +0800</pubDate><description><![CDATA[Proc_sleep程序是Lenix进程状态控制程序中的一个，与其对应的是Proc_wakeup程序。
其代码
void        Proc_sleep(void)
{
    if( proc_current == proc_lenix )
        Sys_halt("Lenix try to sleep.");
        
    proc_current->proc_s]]></description><category></category></item><item><title><![CDATA[Lenix消息机制源代码分析]]></title><link>https://blog.csdn.net/robin97/article/details/7077624</link><guid>https://blog.csdn.net/robin97/article/details/7077624</guid><author>robin97</author><pubDate>Fri, 16 Dec 2011 15:06:37 +0800</pubDate><description><![CDATA[对象定义及操作接口typedef struct _msg_slot_t
{
    uint32_t                ms_pid;                         /*  发送进程id              */
    uint32_t                ms_type;                        /*  消息类型]]></description><category></category></item><item><title><![CDATA[进程间通信]]></title><link>https://blog.csdn.net/robin97/article/details/7071396</link><guid>https://blog.csdn.net/robin97/article/details/7071396</guid><author>robin97</author><pubDate>Thu, 15 Dec 2011 09:12:01 +0800</pubDate><description><![CDATA[进程间通信（IPC）是指两个以上的进程之间传递数据。前面提到的同步问题实际上就属于进程间通信的问题，只是其数据量很小。进程间通信的数据量有大有小，根据不同的数据量，各种操作系统都会提供与其相适应的方法。常见的方法有消息、邮箱、管道、共享内存、共享文件等等。其中消息、邮箱、管道都属于先进先出工作方式，而共享内存、共享文件则可以随机访问。同步机制的实现大多是采用共享内存的方式。
进程间通信都会涉及同]]></description><category></category></item><item><title><![CDATA[回头看进程的创建]]></title><link>https://blog.csdn.net/robin97/article/details/7070401</link><guid>https://blog.csdn.net/robin97/article/details/7070401</guid><author>robin97</author><pubDate>Wed, 14 Dec 2011 14:58:01 +0800</pubDate><description><![CDATA[这个时候回头看进程的创建，在进程池中查找空闲的进程对象时，就属于一个临界段代码，并没有任何的约束，所以这时存在很大的隐患的。现在利用锁机制对其进行改写，有了锁的保护，还可以同时加入pid生成代码。
proc_t  *   Proc_create(const char * name,void * entry,void * param,void * stack)
{
    static uint3]]></description><category></category></item><item><title><![CDATA[进程同步：问题的解决，原语]]></title><link>https://blog.csdn.net/robin97/article/details/7069990</link><guid>https://blog.csdn.net/robin97/article/details/7069990</guid><author>robin97</author><pubDate>Wed, 14 Dec 2011 13:25:12 +0800</pubDate><description><![CDATA[在出现了同步问题后，如何解决呢？可以在访问公共变量的时候，设置一个锁变量，这个锁变量有两个状态，一个是上锁的状态，另一个是释放状态，如果锁变量没有上锁，则可以访问变量，同时将锁置为上锁状态。待访问变量结束后，将锁置为释放状态，允许下一个进程访问变量。示例的程序如下：
int     lock = 0;
int     cnt = 0;

int     app1(void)
{
    int]]></description><category></category></item><item><title><![CDATA[进程同步，问题的引入]]></title><link>https://blog.csdn.net/robin97/article/details/7069772</link><guid>https://blog.csdn.net/robin97/article/details/7069772</guid><author>robin97</author><pubDate>Wed, 14 Dec 2011 12:09:08 +0800</pubDate><description><![CDATA[当系统存在多个进程对同一个变量进行访问时，就会出现进程同步问题。这里先利用Lenix来制造出一个因为同步问题而出现错误的情况。
原始的代码是
int     cnt = 0;
int     app1(void)
{
    int     tmp;
    
    printf("app1 count:%d\n",cnt);
    tmp = cnt + 1;
    printf("a]]></description><category></category></item><item><title><![CDATA[进程管理测试（1）]]></title><link>https://blog.csdn.net/robin97/article/details/7069184</link><guid>https://blog.csdn.net/robin97/article/details/7069184</guid><author>robin97</author><pubDate>Wed, 14 Dec 2011 09:57:41 +0800</pubDate><description><![CDATA[有了之前的了解，可以对进程管理进行一个测试。在测试之前，还需要做一些准备工作。
首先，需要增加一个刷新调度因子的程序，如果没有这个程序，调度因子将一直为0。
void        Proc_alarm(void)
{
    int i;
    
    for( i = 1 ; i < PROC_MAX ; i++)
    {
        if( !proc_pool[i].pro]]></description><category></category></item><item><title><![CDATA[Lenix进程管理源代码分析（第一阶段）]]></title><link>https://blog.csdn.net/robin97/article/details/7068296</link><guid>https://blog.csdn.net/robin97/article/details/7068296</guid><author>robin97</author><pubDate>Wed, 14 Dec 2011 09:27:02 +0800</pubDate><description><![CDATA[由于进程会随着功能的增加而变大，也会导致进程管理行为发生变化。要说明进程管理，并不是功能越多越好，而应该在具备基本功能的最小集合下进行，如果有太多的其他内容，反而会造成理解上的困难。
首先，Lenix定义了一个全局进程数组，这个数组就是用来分配进程对象的，也就是PCB
proc_t                  *   proc_current;

static proc_t]]></description><category></category></item><item><title><![CDATA[进程管理]]></title><link>https://blog.csdn.net/robin97/article/details/7068117</link><guid>https://blog.csdn.net/robin97/article/details/7068117</guid><author>robin97</author><pubDate>Wed, 14 Dec 2011 08:13:00 +0800</pubDate><description><![CDATA[进程管理主要是完成进程的创建、退出、状态的转换、进程切换
1、进程的创建。进程的创建主要完成几个任务，从创建进程对象开始，也就是为PCB分配内存，然后分配相应的资源，例如内存、IO设备等，分配好资源后，如果程序处于外存，还要将程序从外存读入，这个过程可以称为装载，装载完成后，初始化进程的运行环境，例如各个寄存器的初始值，然后根据初始状态设置PCB，最后将进程放入调度队列中，等待调度。
2、进程]]></description><category></category></item><item><title><![CDATA[如何表示进程？]]></title><link>https://blog.csdn.net/robin97/article/details/7067628</link><guid>https://blog.csdn.net/robin97/article/details/7067628</guid><author>robin97</author><pubDate>Tue, 13 Dec 2011 17:36:49 +0800</pubDate><description><![CDATA[进程是操作系统中最重要的概念，但是进程如何表示？通常的操作系统书籍都用了一个词：进程控制块，简称：PCB。也就是在一块连续的内存中包含了进程的各种信息。这些信息通常包含
1、标识信息。主要是用于识别进程，常见的有进程名，进程id，用户id等等。
2、调度信息。像栈指针，CPU时间、进程状态和一些调度相关参数。
3、资源信息。例如打开的文件列表、已经打开的内核对象列表等。
4、各类统计信息。]]></description><category></category></item><item><title><![CDATA[进程]]></title><link>https://blog.csdn.net/robin97/article/details/7067164</link><guid>https://blog.csdn.net/robin97/article/details/7067164</guid><author>robin97</author><pubDate>Tue, 13 Dec 2011 16:55:37 +0800</pubDate><description><![CDATA[进程这个词，相信大多数人并不陌生。在用windows的时候，经常会打开任务管理器，里面就有一个选项卡是进程。

在一般的概念中，运行一个程序，就会有一个对应的进程。基本上就将进程等同于程序。这是一般人对于进程的理解，如果要学习操作系统，就要有更全面、准确的认识。
 
进程是操作系统中最重要的概念，可以说进程是现代操作系统的核心。对于进程的概念，现在有众多的说法，但可以说，都没有办法让人很好]]></description><category></category></item><item><title><![CDATA[基础3：硬件编程]]></title><link>https://blog.csdn.net/robin97/article/details/7067018</link><guid>https://blog.csdn.net/robin97/article/details/7067018</guid><author>robin97</author><pubDate>Tue, 13 Dec 2011 15:26:37 +0800</pubDate><description><![CDATA[这部分内容是Lenix基础的最后一部分，就是硬件知识。但是由于Lenix是学习用的，所涉及的硬件不多，只需要用到8259中断控制器、时钟、键盘。这部分内容这里就不细讲，在书上会说明。
由于C语言并没有提供直接操作端口的方式，因此Lenix设计了两个程序，用于完成端口的IO
;	byte_t	Io_inb(word_t port)
_Io_inb:
	mov		bx,sp
	xor		ax,ax]]></description><category></category></item><item><title><![CDATA[基础2：中断处理]]></title><link>https://blog.csdn.net/robin97/article/details/7065616</link><guid>https://blog.csdn.net/robin97/article/details/7065616</guid><author>robin97</author><pubDate>Tue, 13 Dec 2011 12:10:27 +0800</pubDate><description><![CDATA[响应中断是操作系统最重要的任务之一，所以要写操作系统，就要知道如何设置中断处理程序，以及中断处理程序的编写。
x86CPU在实模式下，中断是通过中断向量表来转发的，这个中断向量表是固定在物理地址0 - 3FF处。大致来说，就是x86CPU可以处理256个中断，每个中断的中断处理程序用四个字节表示，因此总共占用1K个字节。具体的细节就不再这里写了。这里主要是讲怎么进行中断处理。
第一步：
设置]]></description><category></category></item><item><title><![CDATA[所需的基础知识]]></title><link>https://blog.csdn.net/robin97/article/details/7064861</link><guid>https://blog.csdn.net/robin97/article/details/7064861</guid><author>robin97</author><pubDate>Tue, 13 Dec 2011 09:27:33 +0800</pubDate><description><![CDATA[这里是我需要写的    《操作系统原理及实践》的草稿，只是一个框架，会有一些省略的地方，比如图表，文字也是一些大纲性质的，并没做很细致的说明，但是代码是可以保证的，代码分析相对简单，为什么这么做的说明也是一个提示性的文字，这些会在后面进行补充。如果有心学，并没有太大的困难。
=============================================================]]></description><category></category></item><item><title><![CDATA[我带徒弟的方式。]]></title><link>https://blog.csdn.net/robin97/article/details/7063577</link><guid>https://blog.csdn.net/robin97/article/details/7063577</guid><author>robin97</author><pubDate>Mon, 12 Dec 2011 17:41:37 +0800</pubDate><description><![CDATA[很多人在学编程的时候，总会希望有个人带，如果没人带，也就踏上了自学的道路。虽然，最终的修行是靠个人，但是如果有人带，路将会好走很多，少走很多弯路。这个有人带的说法，我是指类似师傅带徒弟的方式，就其形式来说，也就是一个人带2、3个，顶多带4、5个人。如果要参加那种培训班式的，一个班里有2、30个人，甚至多到4、50个人的，还不如自学呢。
    学编程，如果不是因为兴趣，那自然是想找一份好工作，但]]></description><category></category></item></channel></rss>