SigmaOS应用资源分配与运行全流程分析

概述

SigmaOS是一个实验性的云操作系统，采用分布式架构设计，具有多层调度系统和容器化执行环境。本报告详细分析了SigmaOS从接收应用请求到完成资源分配并运行应用的完整流程。

系统架构概览

SigmaOS采用分层架构，主要组件包括：

1. 内核层 (Kernel Layer)：管理系统资源和服务
2. 调度层 (Scheduler Layer)：包含多级调度器
3. 进程管理层 (Process Management Layer)：管理进程生命周期
4. 容器层 (Container Layer)：提供隔离的执行环境
5. 文件系统层 (Filesystem Layer)：提供分布式文件系统

核心组件详解

1. 调度系统 (Scheduler System)

1.1 BESched (Best-Effort Scheduler)

• 位置: sched/besched/srv/srv.go
• 功能: 管理最佳努力类型的进程队列，负责进程的初始调度决策
• 关键方法:
• Enqueue(): 将进程加入调度队列
• GetProc(): 为MSched提供可调度的进程

1.2 MSched (Machine Scheduler)

• 位置: sched/msched/srv/srv.go
• 功能: 每台机器上的调度代理，负责本地资源管理和进程执行
• 关键方法:
• getQueuedProcs(): 从BESched获取待执行进程
• spawnAndRunProc(): 生成并运行进程
• ForceRun(): 强制运行特权进程

1.3 LCSched (Latency-Critical Scheduler)

• 位置: sched/lcsched/srv/srv.go
• 功能: 管理延迟敏感的进程调度

2. 进程管理系统

2.1 ProcMgr (Process Manager)

• 位置: sched/msched/srv/procmgr/procmgr.go
• 功能: 管理进程的生命周期和状态
• 关键方法:
• Spawn(): 进程生成
• RunProc(): 执行进程
• setupProcState(): 设置进程状态

2.2 ProcClnt (Process Client)

• 位置: sigmaclnt/procclnt/procclnt.go
• 功能: 提供进程操作的客户端接口
• 关键方法:
• Spawn(): 生成新进程
• WaitStart(): 等待进程启动
• WaitExit(): 等待进程退出

3. 容器系统

3.1 SContainer

• 位置: scontainer/scontainer.go
• 功能: 提供容器化的执行环境
• 特性: 使用Linux命名空间进行隔离

应用运行全流程

graph TD
    A[应用请求] --> B[ProcClnt.Spawn]
    B --> C{进程类型判断}

    C -->|特权进程| D[直接发送到MSched]
    C -->|BE进程| E[发送到BESched]
    C -->|LC进程| F[发送到LCSched]

    E --> G[BESched.Enqueue]
    G --> H[进程入队列]
    H --> I[MSched.getQueuedProcs]

    F --> J[LCSched调度]
    J --> K[选择目标MSched]

    D --> L[MSched.ForceRun]
    I --> M[BESched.GetProc]
    K --> L

    M --> N{资源检查}
    N -->|资源充足| O[返回进程给MSched]
    N -->|资源不足| P[等待资源释放]
    P --> M

    O --> Q[MSched.spawnAndRunProc]
    L --> Q

    Q --> R[ProcMgr.Spawn]
    R --> S[ProcMgr.RunProc]
    S --> T{进程类型}

    T -->|特权进程| U[runPrivilegedProc]
    T -->|用户进程| V[runUserProc]

    U --> W[kproc.RunKernelProc]
    V --> X[ProcdMgr.RunUProc]

    X --> Y[ProcClnt.RunProc]
    Y --> Z[StartSigmaContainer]

    Z --> AA[uproc-trampoline]
    AA --> BB[应用程序执行]

    W --> BB
    BB --> CC[进程完成]
    CC --> DD[资源清理]
    DD --> EE[状态更新]

详细流程步骤

阶段1: 应用提交与初始调度

1. 应用提交
2. 用户通过ProcClnt.Spawn()提交应用

3. 系统创建proc.Proc对象，包含应用的资源需求和配置信息

4. 进程类型分类 go if p.IsPrivileged() { // 特权进程直接发送到指定MSched err = clnt.forceRunViaMSched(kernelId, p) } else if p.GetType() == proc.T_BE { // BE进程通过BESched调度 mschedID, pseqno, err = clnt.enqueueViaBESched(p) } else { // LC进程通过LCSched调度 spawnedMSchedID, err = clnt.enqueueViaLCSched(p) }

5. BESched队列管理

6. BE进程进入BESched的优先级队列
7. 按照资源需求和优先级排序
8. 支持多realm隔离

阶段2: 资源分配与调度决策

1. MSched资源检查 go func (msched *MSched) shouldGetBEProc() (proc.Tmem, bool) { mem := msched.getFreeMem() cpu := msched.getCPUUtil() return mem, mem > 0 && cpu < TARGET_CPU_UTIL }

2. 进程获取与分配

3. MSched定期调用getQueuedProcs()
4. 从BESched获取符合资源条件的进程

5. 考虑内存、CPU利用率等约束

6. 负载均衡

7. 支持bias机制，优先选择本地kernel的进程
8. 失败时自动切换到其他procq

阶段3: 进程生成与执行

1. 进程生成 go func (msched *MSched) spawnAndRunProc(p *proc.Proc, pseqno *proc.ProcSeqno) { msched.incRealmStats(p) p.SetKernelID(msched.kernelID, false) msched.pmgr.Spawn(p) go msched.runProc(p) }

2. 进程状态设置

3. 设置进程的kernel ID
4. 创建进程目录结构

5. 初始化同步原语（信号量）

6. 容器化执行 ```go func StartSigmaContainer(uproc proc.Proc, dialproxy bool) (uprocCmd, error) { cmd := exec.Command("uproc-trampoline", uproc.GetPid().String(), binsrv.BinPath(uproc.GetVersionedProgram()), strconv.FormatBool(dialproxy), uproc.Args...)

   cmd.SysProcAttr = &syscall.SysProcAttr{ Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS, } } ```

阶段4: 运行时管理

1. 进程监控

   • MSched持续监控进程状态
   • 处理进程启动、运行、退出事件
   • 维护资源使用统计

2. 资源回收

   • 进程退出时释放分配的资源
   • 更新MSched的可用资源计数
   • 清理进程相关的文件系统状态

关键设计特性

1. 多级调度架构

• BESched: 全局调度决策
• MSched: 本地资源管理
• LCSched: 延迟敏感调度

2. 资源感知调度

type MSched struct {
    mcpufree    proc.Tmcpu  // 可用CPU资源
    memfree     proc.Tmem   // 可用内存资源
    cpuUtil     int64       // CPU利用率
}

3. 容器化隔离

• 使用Linux命名空间提供进程隔离
• 支持自定义的uproc-trampoline启动器
• 提供安全的执行环境

4. 分布式文件系统

• 统一的命名空间
• 支持多种后端存储（S3、本地文件系统等）
• 透明的文件访问

5. 故障处理

• 自动重试机制
• 进程崩溃检测和清理
• 资源泄漏防护

性能优化策略

1. 预热机制

func (msched *MSched) WarmProcd(ctx fs.CtxI, req proto.WarmCacheBinReq, res *proto.WarmCacheBinRep) error {
    return msched.pmgr.WarmProcd(sp.Tpid(req.PidStr), sp.Trealm(req.RealmStr), 
                                req.Program, req.SigmaPath, proc.Ttype(req.ProcType))
}

2. 二进制缓存

• 在MSched上缓存常用的应用二进制文件
• 减少网络传输开销
• 加速应用启动

3. 资源池化

• 维护进程池以减少启动开销
• 复用容器和资源
• 动态调整池大小

4. 负载感知

• 实时监控CPU和内存使用率
• 基于负载进行调度决策
• 避免资源过载

示例应用执行流程

以MapReduce应用为例：

1. 作业提交 go func StartMRJob(sc *sigmaclnt.SigmaClnt, jobRoot, jobName string, job *Job, nmap int, memPerTask proc.Tmem, maliciousMapper int) *procgroupmgr.ProcGroupMgr { cfg := procgroupmgr.NewProcGroupConfig(NCOORD, "mr-coord", []string{jobRoot, strconv.Itoa(nmap), strconv.Itoa(job.Nreduce), "mr-m-" + job.App, "mr-r-" + job.App, ...}, 1000, jobName) return cfg.StartGrpMgr(sc) }

2. Coordinator启动

3. 创建mr-coord进程
4. 分配资源并调度到合适的MSched

5. 初始化作业状态

6. Mapper进程生成

7. Coordinator根据输入数据创建多个mapper进程
8. 每个mapper分配独立的资源

9. 并行执行map任务

10. Reducer进程生成

11. 在map阶段完成后启动reducer进程
12. 处理中间结果
13. 生成最终输出

总结

SigmaOS的应用运行流程体现了现代云操作系统的设计理念：

1. 分层架构: 清晰的职责分离，便于扩展和维护
2. 资源感知: 智能的资源分配和调度决策
3. 容器化: 安全的隔离执行环境
4. 分布式: 支持大规模集群部署
5. 高性能: 多种优化策略确保系统效率

这种设计使得SigmaOS能够高效地管理和执行各种类型的应用，从简单的用户程序到复杂的分布式计算任务，都能得到良好的支持。

参考文件

• sched/msched/srv/srv.go - MSched核心实现
• sched/besched/srv/srv.go - BESched调度器
• sigmaclnt/procclnt/procclnt.go - 进程客户端接口
• sched/msched/srv/procmgr/procmgr.go - 进程管理器
• scontainer/scontainer.go - 容器化执行
• apps/mr/job.go - MapReduce应用示例