Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· OpenAIAi2 WildChat-4.8M (AI2)

使用C语言,设计一个程序;…

  1. User

    使用C语言,设计一个程序; 1.创建后备作业(20个),作业需要的内存,需要的A,B,C类资源随机生成,生成的内存小于512K,生成A资源小于6,生成B资源小于3,生成C资源小于4, 2.作业调度,按先来先服选择一部分作业(最多5个)进入内存; 为每个作业创建一个进程,进程调度算法:时间片轮转 3.分配内存(用户内存:1024K)及相应资源(系统资源A=20,B=8,C=12),内存管理策略:动态分区分配方式(首次适应算法) 给前五个作业分配完时,显示这五个作业的信息(所需内存和资源),以及系统的内存分配情况 结束时显示相关信息: 完成作业信息(提交时间,进入内存时间,完成时间,周转时间,带权周转时间,平均周转时间,平均带权周转时间)

  2. Assistant

    下面是一个使用C语言实现上述功能的程序示例:

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    // 定义作业的数据结构
    typedef struct Job {
        int id; // 作业ID
        int memory; // 需要的内存
        int resourceA; // 需要的A类资源
        int resourceB; // 需要的B类资源
        int resourceC; // 需要的C类资源
        int arrivalTime; // 提交时间
        int enterMemoryTime; // 进入内存时间
        int completionTime; // 完成时间
        int turnaroundTime; // 周转时间
        float weightedTurnaroundTime; // 带权周转时间
    } Job;
    
    // 最大作业数量
    #define MAX_JOBS 20
    // 内存大小
    #define MEMORY_SIZE 1024
    // 资源数量
    #define RESOURCE_A 20
    #define RESOURCE_B 8
    #define RESOURCE_C 12
    
    // 动态分区分配节点
    typedef struct MemoryPartition {
        int start; // 起始地址
        int size; // 分区大小
        int jobId; // 作业ID
        struct MemoryPartition* next; // 下一个分区节点
    } MemoryPartition;
    
    // 作业队列
    Job jobs[MAX_JOBS];
    int jobCount = 0;
    // 内存分区链表头节点
    MemoryPartition* memoryPartitionList;
    
    // 随机生成作业所需的资源和内存
    void generateJobs() {
        int i;
        srand(time(NULL));
        for (i = 0; i < MAX_JOBS; i++) {
            jobs[i].id = i + 1;
            jobs[i].memory = rand() % 512 + 1; // 生成1-512之间的随机数
            jobs[i].resourceA = rand() % 6;
            jobs[i].resourceB = rand() % 3;
            jobs[i].resourceC = rand() % 4;
            jobs[i].arrivalTime = 0;
            jobs[i].enterMemoryTime = 0;
            jobs[i].completionTime = 0;
            jobs[i].turnaroundTime = 0;
            jobs[i].weightedTurnaroundTime = 0.0;
        }
    }
    
    // 获取当前时间
    int getCurrentTime() {
        return (int)time(NULL);
    }
    
    // 添加作业到内存分区链表
    void addJobToMemory(int jobId, int jobMemory) {
        MemoryPartition* newNode = (MemoryPartition*)malloc(sizeof(MemoryPartition));
        newNode->start = 0;
        newNode->size = jobMemory;
        newNode->jobId = jobId;
        newNode->next = NULL;
        
        if (memoryPartitionList == NULL) {
            memoryPartitionList = newNode;
        } else {
            MemoryPartition* p = memoryPartitionList;
            while (p->next != NULL) {
                p = p->next;
            }
            p->next = newNode;
        }
    }
    
    // 从内存分区链表中删除作业
    void removeJobFromMemory(int jobId) {
        MemoryPartition* p = memoryPartitionList;
        MemoryPartition* prev = NULL;
        while (p != NULL) {
            if (p->jobId == jobId) {
                if (prev == NULL) {
                    memoryPartitionList = p->next;
                } else {
                    prev->next = p->next;
                }
                free(p);
                break;
            }
            prev = p;
            p = p->next;
        }
    }
    
    // 检查内存是否足够分配给作业
    int checkMemory(int jobMemory) {
        MemoryPartition* p = memoryPartitionList;
        while (p != NULL) {
            if (p->size >= jobMemory) {
                return 1;
            }
            p = p->next;
        }
        return 0;
    }
    
    // 打印内存分配情况
    void printMemoryStatus() {
        MemoryPartition* p = memoryPartitionList;
        printf("当前内存分配情况:\n");
        while (p != NULL) {
            printf("内存起始地址:%d,分区大小:%d,作业ID:%d\n", p->start, p->size, p->jobId);
            p = p->next;
        }
        printf("\n");
    }
    
    // 首次适应算法
    int firstFit(int jobMemory) {
        MemoryPartition* p = memoryPartitionList;
        while (p != NULL) {
            if (p->size >= jobMemory) {
                return p->start;
            }
            p = p->next;
        }
        return -1; // 内存不足
    }
    
    // 进程调度算法:时间片轮转
    void processScheduling() {
        int i, j;
        int timeSlice = 1; // 时间片
        int timeQuantum = 0; // 当前时间片轮转剩余时间
        int currentTime = getCurrentTime();
        printf("当前时间:%d\n", currentTime);
        
        for (i = 0; i < MAX_JOBS; i++) {
            // 提取前五个作业
            if (i < 5) {
                jobs[i].arrivalTime = currentTime;
                
                // 需要的资源不超过系统资源上限
                if (jobs[i].resourceA <= RESOURCE_A && jobs[i].resourceB <= RESOURCE_B && jobs[i].resourceC <= RESOURCE_C) {
                    // 检查内存是否足够
                    if (checkMemory(jobs[i].memory)) {
                        // 分配内存
                        int start = firstFit(jobs[i].memory);
                        addJobToMemory(jobs[i].id, jobs[i].memory);
                        jobs[i].enterMemoryTime = getCurrentTime();
                        printf("作业 %d 进入内存!\n", jobs[i].id);
                        printf("作业 %d 所需的内存:%d,资源 A:%d,资源 B:%d,资源 C:%d\n", jobs[i].id, jobs[i].memory, jobs[i].resourceA, jobs[i].resourceB, jobs[i].resourceC);
                        printf("\n");
                        
                        // 更新系统资源
                        RESOURCE_A -= jobs[i].resourceA;
                        RESOURCE_B -= jobs[i].resourceB;
                        RESOURCE_C -= jobs[i].resourceC;
                    }
                } else {
                    printf("作业 %d 需要的资源超过系统资源上限,无法进入内存!\n", jobs[i].id);
                    printf("\n");
                }
            }
            
            // 运行作业
            if (jobs[i].enterMemoryTime != 0) {
                while (timeQuantum < timeSlice && timeQuantum < jobs[i].memory) {
                    printf("作业 %d 在运行!剩余时间片:%d\n", jobs[i].id, timeSlice - timeQuantum);
                    timeQuantum++;
                }
                
                // 完成作业
                if (timeQuantum == jobs[i].memory) {
                    jobs[i].completionTime = getCurrentTime();
                    jobs[i].turnaroundTime = jobs[i].completionTime - jobs[i].arrivalTime;
                    jobs[i].weightedTurnaroundTime = (float)jobs[i].turnaroundTime / jobs[i].memory;
                    printf("作业 %d 完成!\n", jobs[i].id);
                    printf("作业 %d 周转时间:%d,带权周转时间:%f\n", jobs[i].id, jobs[i].turnaroundTime, jobs[i].weightedTurnaroundTime);
                    printf("\n");
                    
                    // 释放内存
                    removeJobFromMemory(jobs[i].id);
                    
                    // 更新系统资源
                    RESOURCE_A += jobs[i].resourceA;
                    RESOURCE_B += jobs[i].resourceB;
                    RESOURCE_C += jobs[i].resourceC;
                }
            }
            
            // 当前时间片轮转结束
            if (i == 4 || i == MAX_JOBS - 1) {
                timeQuantum = 0;
                currentTime = getCurrentTime();
                printf("当前时间:%d\n", currentTime);
                printf("\n");
            }
        }
    }
    
    int main() {
        generateJobs();
        processScheduling();
        printMemoryStatus();
        
        return 0;
    }
    

    注意:上述程序使用了伪随机数生成器,可能在不同的操作系统或运行时环境下输出略有差异。此外,内存分区分配使用了简单的首次适应算法,并没有处理碎片问题。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.