Why is the first query time slower than subsequent queries?

[nhthong2001]

I did a demo to test the performance of microstream.

Class root:

public class DataRoot {
    private final List<Group> groups = new ArrayList<>();

    public List<Group> getGroups() {
        return groups;
    }
}

Class Group:

public class Group extends AbstractModel{
    private Set<Project> projectList;
    private Employee groupLeader;

    public Group() {
    }

    public Group(long id, Set<Project> projectList, Employee groupLeader) {
        super(id);
        this.projectList = projectList;
        this.groupLeader = groupLeader;
    }

    public Group(long id, Employee leader) {
        super(id);
        this.groupLeader = leader;
    }

    public Set<Project> getProjectList() {
        return projectList;
    }

    public void setProjectList(Set<Project> projectList) {
        this.projectList = projectList;
    }

    public Employee getGroupLeader() {
        return groupLeader;
    }

    public void setGroupLeader(Employee groupLeader) {
        this.groupLeader = groupLeader;
    }
}

Class Project:

public class Project extends AbstractModel {
    private String projectName;
    private Employee projectLeader;
    private Set<Employee> employees;

    public Project() {
    }

    public Project(long id, String projectName, Employee projectLeader, Set<Employee> employees) {
        super(id);
        this.projectName = projectName;
        this.projectLeader = projectLeader;
        this.employees = employees;
    }

    public String getProjectName() {
        return projectName;
    }

    public void setProjectName(String projectName) {
        this.projectName = projectName;
    }

    public Employee getProjectLeader() {
        return projectLeader;
    }

    public void setProjectLeader(Employee projectLeader) {
        this.projectLeader = projectLeader;
    }

    public Set<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }

}

Class Employee:

public class Employee extends AbstractModel{
    private String visa;

    private Set<Role> roles;



    public Employee() {
    }

    public Employee(long id, String visa, Set<Role> roles) {
        super(id);
        this.visa = visa;
        this.roles = roles;
    }


    public String getVisa() {
        return visa;
    }

    public void setVisa(String visa) {
        this.visa = visa;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
}

I try the query to find all projects with the code below:

public List<Project> getAllProjects() {
        long before = System.currentTimeMillis();

        List<Project> results = root.getGroups()
                .stream()
                .flatMap(group -> group.getProjectList().stream())
                .sorted(Comparator.comparing(Project::getId))
                .collect(Collectors.toList());

        long after = System.currentTimeMillis();
        System.out.println("Query all projects: " + (after - before) + "ms");

        return results;
    }

Test results with 300,000 groups and each group has 2 projects. I config with 1 channel. When I upload data and run it 4 times in a row:

• Query all projects: 107ms, 51ms, 53ms, 49ms

Why does the first time take longer?

[fh-ms]

The executed Java code gets faster at runtime because of optimization done by the JIT compiler of the JVM. After your data was loaded into memory, MicroStream isn't involved anymore when querying or traversing your object graph. This is pure JVM power.