学科前沿技术作业三

 1、谈谈你对UNIX哲学的理解。

Unix哲学起源于Ken Thompson早期关于如何设计一个服务接口简洁、小巧精干的操作系统的思考，随着Unix文化在学习如何尽可能发掘Thompson设计思想的过程中不断成长，同时一路上还从其它许多地方博采众长。

 

Unix哲学说来不算是一种正规设计方法。它并不打算从计算机科学的理论高度来产生理论上完美的软件。那些毫无动力、松松垮垮而且薪水微薄的程序员们，能在短短期限内，如同神灵附体般造出稳定而新颖的软件——这只不过是经理人永远的梦呓罢了。

 

Unix哲学（同其它工程领域的民间传统一样）是自下而上的，而不是自上而下的。Unix哲学注重实效，立足于丰富的经验。你不会在正规方法学和标准中找到它，它更接近于隐性的半本能的知识，即Unix文化所传播的专业经验。它鼓励那种分清轻重缓急的感觉，以及怀疑一切的态度，并鼓励你以幽默达观的态度对待这些。

 

Unix管道的发明人、Unix传统的奠基人之一Doug McIlroy在[McIlroy78]中曾经说过：

 

（i）让每个程序就做好一件事。如果有新任务，就重新开始，不要往原程序中加入新功能而搞得复杂。

 

（ii）假定每个程序的输出都会成为另一个程序的输入，哪怕那个程序还是未知的。输出中不要有无关的信息干扰。避免使用严格的分栏格式和二进制格式输入。不要坚持使用交互式输入。

 

（��）尽可能早地将设计和编译的软件投入试用, 哪怕是操作系统也不例外，理想情况下, 应该是在几星期内。对拙劣的代码别犹豫，扔掉重写。

 

（iv）优先使用工具而不是拙劣的帮助来减轻编程任务的负担。工欲善其事，必先利其器。

 

后来他这样总结道（引自《Unix的四分之一世纪》（A Quarter Century of Unix [Salus]））：

 

Unix哲学是这样的：一个程序只做一件事，并做好。程序要能协作。程序要能处理文本流，因为这是最通用的接口。

 

Rob Pike, 最伟大的C语言大师之一, 在《Notes on C Programming》中从另一个稍微不同的角度表述了Unix的哲学[Pike]：

 

原则1：你无法断定程序会在什么地方耗费运行时间。瓶颈经常出现在想不到的地方，所以别急于胡乱找个地方改代码，除非你已经证实那儿就是瓶颈所在。

 

原则2：估量。在你没对代码进行估量，特别是没找到最耗时的那部分之前，别去优化速度。

 

原则3：花哨的算法在n很小时通常很慢，而n通常很小。花哨算法的常数复杂度很大。除非你确定n总是很大，否则不要用花哨算法（即使n很大，也优先考虑原则2）。

 

原则4：花哨的算法比简单算法更容易出bug、更难实现。尽量使用简单的算法配合简单的数据结构。

 

原则5：数据压倒一切。如果已经选择了正确的数据结构并且把一切都组织得井井有条，正确的算法也就不言自明。编程的核心是数据结构，而不是算法。

 

原则6：没有原则6。

 

Ken Thompson——Unix最初版本的设计者和实现者，禅宗偈语般地对Pike的原则4作了强调：

 

拿不准就穷举。

 

Unix哲学中更多的内容不是这些先哲们口头表述出来的，而是由他们所作的一切和Unix本身所作出的榜样体现出来的。从整体上来说，可以概括为以下几点：

 

1. 模块原则：使用简洁的接口拼合简单的部件。

 

2. 清晰原则：清晰胜于机巧。

 

3. 组合原则：设计时考虑拼接组合。

 

4. 分离原则：策略同机制分离，接口同引擎分离。

 

5. 简洁原则：设计要简洁，复杂度能低则低。

 

6. 吝啬原则：除非确无它法，不要编写庞大的程序。

 

7. 透明性原则：设计要可见，以便审查和调试。

 

8. 健壮原则：健壮源于透明与简洁。

 

9. 表示原则：把知识叠入数据以求逻辑质朴而健壮。

 

10. 通俗原则：接口设计避免标新立异。

 

11. 缄默原则：如果一个程序没什么好说的，就沉默。

 

12. 补救原则：出现异常时，马上退出并给出足够错误信息。

 

13. 经济原则：宁花机器一分，不花程序员一秒。

 

14. 生成原则：避免手工hack，尽量编写程序去生成程序。

 

15. 优化原则：雕琢前先要有原型，跑之前先学会走。

 

16. 多样原则：决不相信所谓“不二法门”的断言。

 

17. 扩展原则：设计着眼未来，未来总比预想来得快。

 

如果刚开始接触Unix，这些原则值得好好体味一番。谈软件工程的文章常常会推荐大部分的这些原则，但是大多数其它操作系统缺乏恰当的工具和传统将这些准则付诸实践，所以，多数的程序员还不能自始至终地贯彻这些原则。蹩脚的工具、糟糕的设计、过度的劳作和臃肿的代码对他们已经是家常便饭了；他们奇怪，Unix的玩家有什么好烦的呢。

2、了解开源文化。

开放源码软件运动是计算机科学领域的一种文化现象，源自黑客对智慧成果共享、自由的追求。开源运动发展到现在，这种能够积极促进人类文明发展的文化已经渗透到信息、教育、健康等领域，融入了哲学范畴。

开放源码运动的史前史包括了整个Unix，自由软件和黑客文化的历史。“开放源码”一词来源于1997年春天在加州的Palo Alto召开的一个所谓“纯粹程序员”参与的战略研讨会。参加会议的有Todd Anderson, 来自Foresight研究所Chris Peterson， 来自Linux国际协会的John Hall 和Larry Augustin，有硅谷Linux用户协会的Sam Ockman，以及Eric Raymond。 它们关系的是寻找一种方式，来像以前躲避自由软件的人们来推广这种思想，自由软件和自由软件基金会的反商业信条让很多人对自由软件敬而远之。在Eric Raymond的坚持下，他们一致通过了用新的术语：OpenSource（开源软件）来描述他们所推进的软件。

1998年2月23日网景宣布它将发布Navigator浏览器的源代码成为开源软件发展历史的转折点，经过一番激烈争辩，“开放源码”取代“自由软件”成为黑客们对开放原始码软件的代名词。

自由的交换想法? 协作创造一套健壮、对大家有益的系统？不仅仅Linux是开源哲学的受益产物，在学校教学领域也在探索开源模式的应用，以期能够为教学带来一个更高效、更先进、更丰富的教学体系——这就是开源教育。

开源教育模式下，教师们以互联网为媒介共享课件、协作开发课件、交流教学心得。

人类对世界的人是主要通过两种途径：学习他人经历或亲身体验。教育的本质之一就是通过让人们通过学习多少辈先人积累下来的经验，更快更好的建立对世界的正确认识和树立良好的世界观。从这点看，科学的发展、教育的发展和开源的发展所采用的方法论是一致的，而开源正是这种方法论的代名词。

题目：写一个程序，让用户来决定Windows任务管理器（Task Manager）的CPU占用率。程序越精简越好，计算机语言不限。例如，可以实现下面三种情况：

1.    CPU的占用率固定在50%，为一条直线；

2.    CPU的占用率为一条直线，但是具体占用率由命令行参数决定（参数范围1~ 100）；

3.    CPU的占用率状态是一个正弦曲线。

首先，什么是CPU占用率真？《编程之美》写道：“在任务管理器的一个刷新周期内，CPU忙（执行应用程序）的时间和刷新周期总时间的比率，就是CPU的占用率，也就是说，任务管理器中显示的是每个刷新周期内CPU占用率的统计平均值。”

书中提到了多种方法 ，前面几种简单的都是对应单核CPU的。

第一种是通过CPU的主频计算出在一秒种内CPU能运行的空循环次数，再调节忙/闲的时间比（闲时间设为10ms,使接近于系统调度的时间片），此法在双核CPU上运行看不到任何效果。

第二法方法用到了GetTickCount来获取“系统从启动到现在”经历的毫秒值，通过统计的方法来调节时间比。

using System;
using System.Text;
using System.Threading;

namespace _50persentCPU
{
    class Program
    {
        static void Main(string[] args)
        {
            int  busyTime = 10;
            int  startTime = Environment.TickCount;
            Console.WriteLine(startTime .ToString ());
            while (true)
            {
                 startTime = Environment.TickCount;
                while (Environment.TickCount - startTime <= busyTime)
                {
                    //Console.WriteLine(Environment.TickCount.ToString());
                }
                Thread.Sleep(10);
            }
        }
    }
}

CPU占用率还是一直稳定在50%左右。从上图可看出，程序是单线程运行，但由于是运行在双核上，很难猜到具体的运行情况，燥音也比较大。

下面通过SetThreadAffinityMask函数为线程指定CPU亲和性，让线程只运行在特定的CPU核心上

using System;
using System.Text;
using System.Threading;
using System.Runtime.InteropServices;

namespace _50persentCPU
{
    class Program
    {
        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern int SetThreadAffinityMask(IntPtr hWnd, int nIndex);
        static void Main(string[] args)
        {
            IntPtr nHD = new IntPtr(Thread.CurrentThread.ManagedThreadId);
            SetThreadAffinityMask(nHD, 0);
            int  busyTime = 10;
            int  startTime = Environment.TickCount;
            Console.WriteLine(startTime .ToString ());
            while (true)
            {
                 startTime = Environment.TickCount;
                while (Environment.TickCount - startTime <= busyTime)
                {
                    //Console.WriteLine(Environment.TickCount.ToString());
                }
                Thread.Sleep(10);
            }
        }
    }
}

可以看出，线程只占用0号核心的时间片，cpu占用率很稳定在保持在50%，燥音很弱。

通过PerformanceCounter来采集CPU占用率信息，程序中输出可以输各个实例的CPU占用率。但我运行起来看不到任何效果，在双核上运行真是诡异，还得多了解一些东西才行。

using System;
using System.Diagnostics;
using System.Threading;

namespace _50persentCPU2
{

    class Program
    {
        static void MakeUsage(float level)
        {
            PerformanceCounter p = new PerformanceCounter("Processor",  "% Processor Time","_Total");
            while (true)
            {
                if (p.NextValue ()> level)
                {
                    System.Threading.Thread.Sleep(10);
                }
            }
        }
             static void Main(string[] args)
        {
                       MakeUsage(50 );
        }
    }
}

再给出一个C++版的在单核心在运行绘出正弦曲线的例子。

#include "Windows.h"
#include "stdlib.h"
#include "math.h"
#include
#include
const double SPLIT = 0.01;
const int COUNT = 200;
const double PI = 3.14159265;
const int INTERVAL = 300;
int _tmain(int argc, _TCHAR* argv[])
{
    SetProcessAffinityMask(
         GetCurrentProcess(),
         0x00000001          //cpu mask
         );
    DWORD busySpan[COUNT];  //array of busy times
    DWORD idleSpan[COUNT];  //array of idle times
    int half = INTERVAL / 2;
    double radian = 0.0;
    for(int i = 0; i < COUNT; i++)
    {
        busySpan[i] = (DWORD)(half + (sin(PI * radian) * half));
        idleSpan[i] = INTERVAL - busySpan[i];
        radian += SPLIT;
        printf("%d/t%d/n",busySpan[i],INTERVAL-busySpan[i]);
    }
    DWORD startTime = 0;      
    int j = 0;
    while (true)
    {
        j = j % COUNT;
        startTime = GetTickCount();
        while ((GetTickCount() - startTime) <= busySpan[j]) ;
        Sleep(idleSpan[j]);
        j++;
    }
    return 0;
}

 

C#版 双线程编程，使用两个核心的cpu占用率都是正弦曲线。

class1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace CPU
{
    public class Sin1ThreadParam
    {
        public int AffinityMask = 0x00000000;

        public Sin1ThreadParam(int AffinityMask)
        {
            this.AffinityMask = AffinityMask;
        }
    }

    class Sin1
    {
        public void DoWork(object o)
        {
            Sin1ThreadParam param = o as Sin1ThreadParam;
            if (param != null)
            {
                // 设置线程CPU亲和性
                IntPtr nHD = new IntPtr(Thread.CurrentThread.ManagedThreadId);
                Win32.SetThreadAffinityMask(nHD, param.AffinityMask);

                // 采样率
                const double SPLIT = 0.01;
                // 采样总数
                const int COUNT = 200;
                const double PI = 3.14159265;
                // 扫描速度，控制曲线波长
                const int INTERVAL = 300;

                // 忙循环时间长度
                int[] busySpan = new int[COUNT];
                // 闲循环时间长度
                int[] idleSpan = new int[COUNT];
                int half = INTERVAL / 2;
                // X
                double radian = 0.0;

                // 构成一个具有COUNT个采样点的忙、闲循环
                for (int i = 0; i < COUNT; i++)
                {
                    busySpan[i] = (int)((half + (Math.Sin(PI * radian) * half)));
                    idleSpan[i] = INTERVAL - busySpan[i];
                    radian += SPLIT;
                }

                int startTime = 0;
                int j = 0;

                // 按照忙闲循环比率跑死循环和Sleep
                while (true)
                {
                    j = j % COUNT;
                    startTime = Environment.TickCount;
                    while ((Environment.TickCount - startTime) <= busySpan[j])
                    {

                    }
                    Thread.Sleep(idleSpan[j]);
                    j++;
                }
            }
        }
    }
}

program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace CPU
{
    class Win32
    {
        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern int SetThreadAffinityMask(IntPtr hWnd, int nIndex);
    }

    class Program
    {
        static void Main(string[] args)
        {
            Sin1 sin11 = new Sin1();
            Thread t1 = new Thread(new ParameterizedThreadStart(sin11.DoWork));
            Sin1ThreadParam p1 = new Sin1ThreadParam(0);
            Thread t2 = new Thread(new ParameterizedThreadStart(sin11.DoWork));
            Sin1ThreadParam p2 = new Sin1ThreadParam(1);

            t1.Start(p1);
            t2.Start(p2);
        }
    }
}