SystemSetup.java

package mvd.jester.model;

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

/**
 * TaskSet
 */
public class SystemSetup {
    private Set<Task> tasks;
    private final long numberOfProcessors;

    public SystemSetup(Set<Task> tasks, long numberOfProcessors) {
        this.tasks = tasks;
        this.numberOfProcessors = numberOfProcessors;
    }

    /**
     * @return the tasks
     */
    public Set<Task> getTasks() {
        return tasks;
    }

    public void setTasks(Set<Task> tasks) {
        this.tasks = tasks;
    }

    /**
     * @return the numberOfProcessors
     */
    public long getNumberOfProcessors() {
        return numberOfProcessors;
    }

    public double getUtilization() {
        double utilization = 0;
        for (Task t : tasks) {
            utilization += (double) t.getMaximumWcet() / t.getPeriod();
        }

        return utilization;
    }

    @Override
    public String toString() {
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        return gson.toJson(tasks);
    }

    public static SystemSetup fromFile(String path) {
        String jsonString;
        try {
            byte[] encoded = Files.readAllBytes(Paths.get(path));
            jsonString = new String(encoded, Charset.defaultCharset());
        } catch (IOException e) {
            System.out.println(e.getMessage());
            jsonString = new String("");
        }
        return SystemSetup.fromString(jsonString);
    }

    public static SystemSetup fromString(String json) {
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(SortedTaskSet.class, new SortedTaskSet.Deserializer())
                .create();

        SortedTaskSet tasks = gson.fromJson(json, SortedTaskSet.class);
        return new SystemSetup(tasks, 8);
    }

    public static class Builder {
        private long numberOfProcessors = 4;
        private long minPeriod = 100;
        private long maxPeriod = 1000;
        private long minNumberOfSegments = 3;
        private long maxNumberOfSegments = 7;
        private long minNumberOfJobs = 2;
        private long maxNumberOfJobs = 3 * numberOfProcessors / 2;
        private long minWcet = 1;
        private long ratio = randomTaskRatio();

        public Builder() {

        }

        private long randomTaskPeriod() {
            return ThreadLocalRandom.current().nextLong(minPeriod, maxPeriod);
        }

        private long randomTaskRatio() {
            return ThreadLocalRandom.current().nextLong(0, 100);
        }

        private long randomNumberOfSegments() {
            return ThreadLocalRandom.current().nextLong(minNumberOfSegments, maxNumberOfSegments);
        }

        private long randomNumberOfJobs() {
            this.maxNumberOfJobs = 3 * this.numberOfProcessors / 2;
            return ThreadLocalRandom.current().nextLong(minNumberOfJobs, maxNumberOfJobs);
        }

        private long randomWcet(long period, long numberOfSegments) {
            long maxWcet = period / numberOfSegments;

            return ThreadLocalRandom.current().nextLong(minWcet, maxWcet);
        }

        private Task generateTask() {
            boolean serial = randomTaskRatio() > this.ratio;
            long period = randomTaskPeriod();
            long numberOfSegments = 1;
            Set<Segment> segments = new LinkedHashSet<Segment>();
            if (!serial) {
                numberOfSegments = randomNumberOfSegments();
            } else {
                numberOfSegments = 1;
            }
            long parallelNumberOfJobs = serial ? 1 : randomNumberOfJobs();
            for (int i = 0; i < numberOfSegments; ++i) {
                long numberOfJobs = 1;
                if (i % 2 == 1) {
                    numberOfJobs = parallelNumberOfJobs;
                }
                long wcet = randomWcet(period, numberOfSegments);
                segments.add(new Segment(wcet, numberOfJobs));
            }
            return new Task(period, segments);
        }

        private Set<Task> generateTaskSet() {
            // SortedTaskSet taskSet = new SortedTaskSet(priorityManager);
            Set<Task> taskSet = new HashSet<>();

            for (int i = 0; i < 4; ++i) {
                Task task = generateTask();
                taskSet.add(task);
            }

            return taskSet;
        }

        public SystemSetup build() {
            this.ratio = randomTaskRatio();
            Set<Task> taskSet = generateTaskSet();
            return new SystemSetup(taskSet, numberOfProcessors);
        }

        public void rebuild(SystemSetup systemSetup) {
            this.ratio = randomTaskRatio();
            systemSetup.tasks = generateTaskSet();
        }

        public void addTask(SystemSetup systemSetup) {
            systemSetup.tasks.add(generateTask());
        }

        public Builder setNumberOfProcessors(long numberOfProcessors) {
            this.numberOfProcessors = numberOfProcessors;

            return this;
        }

        public Builder setNumberOfSegments(long minNumberOfSegments, long maxNumberOfSegments) {
            this.minNumberOfSegments = minNumberOfSegments;
            this.maxNumberOfSegments = maxNumberOfSegments;

            return this;
        }

        public Builder setPeriods(long minPeriod, long maxPeriod) {
            this.minPeriod = minPeriod;
            this.maxPeriod = maxPeriod;

            return this;
        }

        /**
         * @param maxNumberOfJobs the maxNumberOfJobs to set
         */
        public Builder setNumberOfJobs(long minNumberOfJobs, long maxNumberOfJobs) {
            this.minNumberOfJobs = minNumberOfJobs;
            this.maxNumberOfJobs = maxNumberOfJobs;
            return this;
        }

    }
}