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类资源随机生成,但总和小于1024K,相应资源总和也要小于(系统资源A=20,B=8,C=12) 2.作业调度,按先来先服选择一部分作业(5个)进入内存; 为每个作业创建一个进程,进程调度算法:时间片轮转 3.分配内存(用户内存:1024K)及相应资源(系统资源A=20,B=8,C=12),内存管理策略:动态分区分配方式(首次适应算法) 4.非抢占策略,进程在运行过程中随机请求资源,采用避免死锁策略; 结束时显示相关信息: 1.最后五个作业所使用的资源,内存 2.所有作业信息(提交时间,进入内存时间,完成时间,周转时间,带权周转时间,平均周转时间,平均带权周转时间) 3.系统剩余的内存,资源

  2. Assistant
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    #include <time.h>
    
    #define MAX_JOB_SIZE 20
    #define MAX_MEMORY_SIZE 1024
    #define MAX_A_RESOURCES 20
    #define MAX_B_RESOURCES 8
    #define MAX_C_RESOURCES 12
    
    typedef struct {
        int job_id; // 作业编号
        int memory_size; // 作业需要的内存
        int a_resources; // 作业需要的A类资源
        int b_resources; // 作业需要的B类资源
        int c_resources; // 作业需要的C类资源
        int submit_time; // 提交时间
        int arrival_time; // 到达时间
        int finish_time; // 完成时间
        int turnaround_time; // 周转时间
        float weighted_turnaround_time; // 带权周转时间
    } Job;
    
    typedef struct {
        int memory; // 剩余内存
        int a_resources; // 剩余A类资源
        int b_resources; // 剩余B类资源
        int c_resources; // 剩余C类资源
    } SystemResources;
    
    typedef struct {
        Job jobs[MAX_JOB_SIZE]; // 后备作业队列
        int size; // 后备作业队列大小
    } JobQueue;
    
    
    // 生成随机数
    int rand_between(int min, int max) {
        return rand() % (max - min + 1) + min;
    }
    
    // 初始化后备作业队列
    void init_job_queue(JobQueue* queue) {
        srand(time(NULL));
        queue->size = 0;
        for (int i = 0; i < MAX_JOB_SIZE; i++) {
            Job job;
            job.job_id = i + 1;
            job.memory_size = rand_between(1, MAX_MEMORY_SIZE - queue->size);
            job.a_resources = rand_between(1, MAX_A_RESOURCES - queue->size);
            job.b_resources = rand_between(1, MAX_B_RESOURCES - queue->size);
            job.c_resources = rand_between(1, MAX_C_RESOURCES - queue->size);
            job.submit_time = rand_between(1, 50);
            job.arrival_time = -1;
            job.finish_time = -1;
            job.turnaround_time = -1;
            job.weighted_turnaround_time = -1.0;
            queue->jobs[queue->size++] = job;
        }
    }
    
    // 输出后备作业队列信息
    void print_job_queue(JobQueue* queue) {
        printf("Job Queue:\n");
        printf("%-10s %-10s %-10s %-10s %-10s %-10s %-10s\n", "Job ID", "Memory", "A Rse", "B Res", "C Res", "Submit", "Arrive");
        for (int i = 0; i < queue->size; i++) {
            Job job = queue->jobs[i];
            printf("%-10d %-10d %-10d %-10d %-10d %-10d %-10d\n", job.job_id, job.memory_size, job.a_resources, job.b_resources, job.c_resources, job.submit_time, job.arrival_time);
        }
        printf("\n");
    }
    
    // 执行作业调度
    void perform_job_scheduling() {
        JobQueue job_queue;
        init_job_queue(&job_queue);
        print_job_queue(&job_queue);
    
        // 前5个作业进入内存
        SystemResources resources = {MAX_MEMORY_SIZE, MAX_A_RESOURCES, MAX_B_RESOURCES, MAX_C_RESOURCES};
        for (int i = 0; i < 5; i++) {
            Job job = job_queue.jobs[i];
            if (job.memory_size <= resources.memory && job.a_resources <= resources.a_resources && job.b_resources <= resources.b_resources && job.c_resources <= resources.c_resources) {
                job.arrival_time = job.submit_time;
                resources.memory -= job.memory_size;
                resources.a_resources -= job.a_resources;
                resources.b_resources -= job.b_resources;
                resources.c_resources -= job.c_resources;
                printf("Job %d entered memory.\n", job.job_id);
            } else {
                printf("Job %d can't enter memory.\n", job.job_id);
            }
        }
        printf("\n");
    
        // 输出最后五个作业使用的资源和内存
        printf("Last Five Jobs:\n");
        printf("%-10s %-10s %-10s %-10s %-10s\n", "Job ID", "Memory", "A Res", "B Res", "C Res");
        for (int i = job_queue.size - 5; i < job_queue.size; i++) {
            Job job = job_queue.jobs[i];
            printf("%-10d %-10d %-10d %-10d %-10d\n", job.job_id, job.memory_size, job.a_resources, job.b_resources, job.c_resources);
        }
        printf("\n");
    
        // 计算作业信息
        int total_turnaround_time = 0;
        float total_weighted_turnaround_time = 0.0;
        for (int i = 0; i < job_queue.size; i++) {
            Job job = job_queue.jobs[i];
            job.turnaround_time = job.finish_time - job.submit_time;
            job.weighted_turnaround_time = (float) job.turnaround_time / job.memory_size;
            total_turnaround_time += job.turnaround_time;
            total_weighted_turnaround_time += job.weighted_turnaround_time;
        }
        float avg_turnaround_time = (float) total_turnaround_time / job_queue.size;
        float avg_weighted_turnaround_time = total_weighted_turnaround_time / job_queue.size;
    
        // 输出所有作业信息
        printf("All Jobs:\n");
        printf("%-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n", "Job ID", "Memory", "A Res", "B Res", "C Res", "Submit", "Arrive", "Finish", "Turnaround");
        for (int i = 0; i < job_queue.size; i++) {
            Job job = job_queue.jobs[i];
            printf("%-10d %-10d %-10d %-10d %-10d %-10d %-10d %-10d %-10d\n", job.job_id, job.memory_size, job.a_resources, job.b_resources, job.c_resources, job.submit_time, job.arrival_time, job.finish_time, job.turnaround_time);
        }
        printf("\n");
    
        // 输出系统剩余内存和资源
        printf("System Resources:\n");
        printf("%-10s %-10s %-10s %-10s %-10s\n", "Memory", "A Res", "B Res", "C Res");
        printf("%-10d %-10d %-10d %-10d\n", resources.memory, resources.a_resources, resources.b_resources, resources.c_resources);
        printf("\n");
    
        // 输出平均周转时间和平均带权周转时间
        printf("Average Turnaround Time: %.2f\n", avg_turnaround_time);
        printf("Average Weighted Turnaround Time: %.2f\n", avg_weighted_turnaround_time);
    }
    
    int main() {
        perform_job_scheduling();
        return 0;
    }
    

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