@wangt21 操作系统实验一个线程调度模型，用时间中断去打断任意函数并在 ISR 里处理调度，然后实验不同的调度算法以及同步原语；还有一块文件系统设计但当初我们的课也很水没涉及到


只能说实验没去，没写到过是挺可惜的。就我们课上写的那一点点东西来说
中断怎么保存 context，怎么 block，怎么查找并调度线程，怎么切换
印象都挺深的


写这个实验最重要的是启发你怎么实现类似的东西本质上是些什么，反正我写完那 100 行的小 demo 再看操作系统就跟最最最开始接触 VB 时拖完那几个控件再看 windows 的感觉是差不多的，拖完控件你马上就意识到程序里那些按钮文本框是怎么回事，写完这个实验你也能马上明白操作系统那些基本部件都是怎么回事

当然了操作系统内容多了去了，也不清楚你们课程安排的是哪些，但个人感觉线程模型是一定要熟悉的东西之一

再补一句，我们当初操作系统的课真的很水！！！实验也是！！
但抓住了 1/1000 最核心的东西，还是有些许欣慰的

N 卡 A 卡解决方案又不同

A 卡现在在官网下载的官方驱动已经支持动态电源管理&切换显卡

只需要用环境变量指定用哪个显卡启动应用即可，独显不处理的时候是 dyn off 状态


当然了 lz 肯定是 N 卡的
N 卡只能说，还是 windows 吧

。。。。。。。。。。
操作系统的每一个子部件拆开都是在实际工程写代码的时候用得上的
lz 单纯是写得太少。。没啥好办法，先硬着头皮记吧，起码能有个印象
等你代码写多了自然会想用某种方式去解决，然后想起诶这个是不是那个什么算法那个机制，再回来翻，就熟悉了


我觉得其实操作系统的实验课程都挺实用啊？线程调度你写得出来就记得住了啊

随机不等于均匀
随机数的分布更不一定是正态分布

真随机数的生成其实很简单，引入随机用户输入即可，benchmark 结果的随机也是由于系统各种运行环境影响产生的，而环境因素与过去历史用户操作密切相关，你其实就是期望通过引入系统运行不稳定性来制造随机

然而系统稳定性是可控的，我们完全可预测可计算 bechmark 什么时候结束，对于你这个算法来说，实际上期望结果是稳定的，完全不随机。

既然期望都是不随机的，你怎么还会想用它来制造随机数？？？

就算误差无法避免，这个算法中也没有过程来放大误差，假设误差时间在 1ms 到 10ms 之间，那随机数种子就只有 1 到 10 这么点结果，随机性能好到哪里去？？？

如果想靠计时误差来产生非可预测随机，首先记时精度一定要够高，并且，需要多次记时并引入混沌过程放大误差结果并消除可逆性，这样才能使种子足够“无法预测”

但无法预测是不是等于随机，抱歉，仍不知道

产生一个不可预测数后，返回固定分布的数很简单，筛子就行

没啥毛病啊
lz 今年最爱的是给孩子放的歌
这不挺好的吗
智障吗？
最爱给孩子放儿歌智障吗？

密码学的数学基础保证了数据既是加密的，也是已公证（可信赖）的

这是现代密码学最神奇的地方

..........................

楼上都在说啥？
antlr ？
ast ？
语法分析的范畴 你搬自己都不太懂的名词出来是不是会砸自己脚？


当然我是百度了一圈才敢回来回帖的，并且我也不敢说我看懂 lz 的东西或他写得对不对，承认自己菜

有个段子
遇到个“饿了给点吃的”的，给了他几个馒头，然后他走了，悄悄跟上，等他重新摆好牌子“饿了给点吃的”，又给他几个馒头。。。

这东西是递归解的，这么说明不明白？

Encode( prefix,numberSeries )
{
if(numberSeries == end()){
output(prefix);
return;
}
curNumber = numberSeries[0];
for(letter in letterTable[curNumber]){
prefix=prefix+letter;
Encode( prefix,numberSeries+1 );
}
}

类 static 成员变量除了要在类内声明，还要在类外定义，但 template 又要求声明和实现都必须放在一起


template<class TYPE>
class CSingleton {
public:
static TYPE *instance() {
return &m_slInstance;
};
public:
CSingleton() {
}
virtual ~CSingleton() {
}
private:
static TYPE m_slInstance;
};
template<class TYPE> TYPE CSingleton<TYPE>::m_slInstance = nullptr;//类外定义并初始化

冬至当然是打边炉啊，羊肉狗肉煲啊

。。广大前端情何以堪

@wisej 首先再强调一次，你期望的“精确的 12.300 ”在浮点运算硬件中是无法存在的，在浮点寄存器中无法存放无法表示，想要精确表示 12.3000，只能有两种办法

1. 不采用浮点数，而用分数表示，也就是这个数就记录为 int(12)+int(3)/int(10)。注意这个方法还是可硬件实现的，只是没有这样的硬件而已。
2. 不采用硬件浮点运算单元，用软件模拟，以 10 进制小数习惯进行运算，4.10e0*3.0e0==1.23e1


第一种方法如果用硬件实现，表示一个数需要 3 部分存储单元而且无法表示无理数，除非为了些莫名其妙的目的专门造否则不可能做这样的硬件。如果软件模拟，则其实跟第二种方法差不多。

那么现在就只剩第二种方法了，软件模拟计算。

软件模拟！

都软件模拟了，还要多说吗？当年 8087 协处理器是用来干啥的，不就是解决 8086 算浮点太慢的问题嘛，没有任何一个现代 CPU 是不带浮点运算单元的，因为实在太重要。


“为什么会采用这种标准” 是一脉相承的，首先有了开关，然后有了二进制和晶体管，然后有了数字电路，然后有了集成电路和定点运算 cpu，然后有了浮点协处理器，然后才有了现代自带浮点单元的 CPU。整个计算机世界的所有标准都是从那个二进制开关传承下来的，如果人们发现的那个可以作为开关的三极管有三个可控稳定态，那么现在数字世界的编码方式很可能就是三进制的了

扯远了，总之你的问题，你以为的因果是 12.29999→数是以二进制表示的→无法精确；但实际上的因果关系是，数字电路必定是二进制的→IEEE 标准浮点→浮点运算器→你看到的结果。



“语言设计者为什么不内部进行处理返回我们所期望的值 12.3 呢” ← 所以，为了能产出不那么反直觉的结果，c/++在输出的时候做了额外处理，使其能重新还原成人们熟悉的小数结果，而 python 默认没这么做，而是另外提供 decimal 模块半软件半硬件地来以人类直觉 10 进制计算小数

@wisej c++里并不是 12.3 仍然是 12.299999，只是在输出的时候有些额外的 workaround


------------------------------------源码----------------------------------------
#include <stdio.h>
int flg = 0;
int main()
{
double v1 = 4.1;
double v2 = 3;
printf("%lf",v1*v2);
}
---------------------------------------------------------------------------------
----------------------------------编译结果------------------------------------

flg:
.zero 4
.LC2:
.string "%lf"
main:
push rbp
mov rbp, rsp
sub rsp, 16
movsd xmm0, QWORD PTR .LC0[rip]
movsd QWORD PTR [rbp-8], xmm0
movsd xmm0, QWORD PTR .LC1[rip]
movsd QWORD PTR [rbp-16], xmm0
movsd xmm0, QWORD PTR [rbp-8]
mulsd xmm0, QWORD PTR [rbp-16]
mov edi, OFFSET FLAT:.LC2
mov eax, 1
call printf
mov eax, 0
leave
ret
.LC0:
.long 1717986918
.long 1074816614
.LC1:
.long 0
.long 1074266112

（可以直接在 https://gcc.godbolt.org/实时查看代码段在不同编译器下的结果）




---------------------------------------GDB-----------------------------------------


[----------------------------------registers-----------------------------------]
RAX: 0x400526 (<main>: push rbp)
RBX: 0x0
RCX: 0x0
RDX: 0x7fffffffddc8 --> 0x7fffffffe1b6 ("XDG_SEAT=seat0")
RSI: 0x7fffffffddb8 --> 0x7fffffffe1ab ("/tmp/a.out")
RDI: 0x1
RBP: 0x7fffffffdcd0 --> 0x400570 (<__libc_csu_init>: push r15)
RSP: 0x7fffffffdcc0 --> 0x4008000000000000
RIP: 0x400552 (<main+44>: mov edi,0x4005f8)
R8 : 0x4005e0 (<__libc_csu_fini>: repz ret)
R9 : 0x7ffff7de7ab0 (<_dl_fini>: push rbp)
R10: 0x846
R11: 0x7ffff7a2d740 (<__libc_start_main>: push r14)
R12: 0x400430 (<_start>: xor ebp,ebp)
R13: 0x7fffffffddb0 --> 0x1
R14: 0x0
R15: 0x0
EFLAGS: 0x206 (carry PARITY adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x400543 <main+29>: movsd QWORD PTR [rbp-0x8],xmm0
0x400548 <main+34>: movsd xmm0,QWORD PTR [rbp-0x10]
0x40054d <main+39>: mulsd xmm0,QWORD PTR [rbp-0x8]
=> 0x400552 <main+44>: mov edi,0x4005f8
0x400557 <main+49>: mov eax,0x1
0x40055c <main+54>: call 0x400400 <printf@plt>
0x400561 <main+59>: mov eax,0x0
0x400566 <main+64>: leave
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffdcc0 --> 0x4008000000000000
0008| 0x7fffffffdcc8 --> 0x4010666666666666
0016| 0x7fffffffdcd0 --> 0x400570 (<__libc_csu_init>: push r15)
0024| 0x7fffffffdcd8 --> 0x7ffff7a2d830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7fffffffdce0 --> 0x0
0040| 0x7fffffffdce8 --> 0x7fffffffddb8 --> 0x7fffffffe1ab ("/tmp/a.out")
0048| 0x7fffffffdcf0 --> 0x100000000
0056| 0x7fffffffdcf8 --> 0x400526 (<main>: push rbp)
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x0000000000400552 in main ()
gdb-peda$ p $xmm0
$1 = {
v4_float = {-1.58818668e-23, 2.63437486, 0, 0},
v2_double = {12.299999999999999, 0},
v16_int8 = {0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x28, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
v8_int16 = {0x9999, 0x9999, 0x9999, 0x4028, 0x0, 0x0, 0x0, 0x0},
v4_int32 = {0x99999999, 0x40289999, 0x0, 0x0},
v2_int64 = {0x4028999999999999, 0x0},
uint128 = 0x00000000000000004028999999999999
}
gdb-peda$


可以很清楚地看到算出来就是 12.29999999999999，这是机器码已经决定了的。只是在 printf 后被%lf 重新格式化成了 12.300000

用户自发驱动的内容有相当的不确定性，是一定没法只用某种单一官方的激励去达到期望场景的，期望有大部分能用户观众能充当裁判身份是不靠谱的，观众本身是最大的噪音来源，他们不产生内容，会被莫名其妙的东西引导，会有（特别在问答社区）严重的盲目性，所以别想着什么都能有第三方监督，三方监督只在观众-题主-回答三个身份都相互独立无法相互干扰的情况下成立，这也是技术性问答社区容易立足，而知乎这种泛问答平台充斥大量垃圾节奏问题的原因

就本帖来说

1. 题主肯为这个问题付 8 块钱吗
2. 有人愿意为了抢这 8 块钱写个 2k 字去详细分析下这个产品方案可不可行吗？反正我肯定不会，专业分析几千字我按 1 字 1 块收还差不多
3. 前面已经有个傻帽闲得慌已经写了 1k 字了但都是错的偏偏他还是个大 v 一堆人点赞你咋办，我选择离开
4. 题主的问题在今天内得到了解决，大家一致认定能成，于是题主随便选了个稍微字多的比如我然后把钱分了，但是 5 年后大家验证后发现这个方案扑街，然后一堆人重新反对+没有帮助，得，那我这 8 块钱还退回去？怎么退？不退了？ 5 年后人家有实践告诉大家真的不可行了，赞同比我这个回答多一倍，然后反而还是我拿钱？？？
5.0. 问题：这个语言特性是怎么实现的？（悬赏 30 ） 回答 1：我也不知道（赞同 10 ）
5.1. 问题：这个语言特性是怎么实现的？（悬赏 30 ） 回答 100：（赞同 1 赞同 2 赞同 1 3 0 0 0 1 0 0 0 ......）
5.2. 上边这俩问题怎么结算？

其它问题

6. 首页-热门回答-第一条：身材非常好是一种什么体验（悬赏 100 ），3k 回答，赏金分了前十。第二条:你家的猫颜值有多高（悬赏 8 ），3k 回答，得分答案：题主先自己来放一张吧 balabala （赞 1k ），第二答案：balabala （赞 996 ）

@whwq2012 电热器哪有功率小的，2kw，开半小时一度电

1. 大神早都过了做作业的阶段，家教辅导小学生写作业还要钱呢 lz 你……
2. wireshark
3. 作业要么抄要么做，抄你同学的就行复制粘贴 refactor 改改变量名提交就行跑这里伸手，噗嗤
4. qt 是个用 c++/qml/js 开发的库，C 语言是行不通的，第一行就行不通谢谢