Examples with ReferenceElements org.iobserve.analysis.test.userbehavior.ReferenceElements used on opensource projects

Example 1 with ReferenceElements

use of org.iobserve.analysis.test.userbehavior.ReferenceElements in project iobserve-analysis by research-iobserve.

the class BranchWithinLoopReference method getModel.

/**
 * It creates a reference usage model that contains branches within loops. Accordingly, user
 * sessions whose call sequences differ from each other are iterated in a row. Thereby, at each
 * iteration of a branched call sequences the probabilities have to be equal because otherwise
 * it would not be an iteration (RQ-1.8)
 *
 * @param referenceUsageModelFileName
 *            reference usage model file name
 * @param repositoryLookupModel
 *            repository model builder
 * @param correspondenceModel
 *            correspondence model
 *
 * @return reference usage model and corresponding user sessions
 * @throws IOException
 *             on error
 */
public static ReferenceElements getModel(final String referenceUsageModelFileName, final RepositoryLookupModelProvider repositoryLookupModel, final CorrespondenceModel correspondenceModel) throws IOException {
    // The number of model element parameters are created randomly. The number of user sessions
    // must be created accordingly to the number of branch transitions, because it must be
    // ensured that at each iteration of an branch the branch transition probabilities are
    // equal. This can be achieved by the same number of user sessions representing the branch
    // transition at each iteration
    final int numberOfLoops = TestHelper.getRandomInteger(3, 3);
    final int numberOfConcurrentUsers = (int) Math.pow(2, numberOfLoops) * 5;
    final UserSessionCollectionModel entryCallSequenceModel = new UserSessionCollectionModel(TestHelper.getUserSessions(numberOfConcurrentUsers));
    final ReferenceElements testElements = new ReferenceElements();
    // In the following the reference usage model is created
    final UsageModel usageModel = UsageModelFactory.createUsageModel();
    final UsageScenario usageScenario = UsageModelFactory.createUsageScenario("", usageModel);
    final ScenarioBehaviour scenarioBehaviour = usageScenario.getScenarioBehaviour_UsageScenario();
    final Start start = UsageModelFactory.createAddStartAction("", scenarioBehaviour);
    final Stop stop = UsageModelFactory.createAddStopAction("", scenarioBehaviour);
    final AbstractUserAction lastAction = start;
    // The loop element is created that contains the iterated branch
    final Loop loop = UsageModelFactory.createLoop("", scenarioBehaviour);
    final ScenarioBehaviour loopScenarioBehaviour = loop.getBodyBehaviour_Loop();
    UsageModelFactory.connect(lastAction, loop);
    final PCMRandomVariable pcmLoopIteration = CoreFactory.eINSTANCE.createPCMRandomVariable();
    pcmLoopIteration.setSpecification(String.valueOf(numberOfLoops));
    // Set number of loops
    loop.setLoopIteration_Loop(pcmLoopIteration);
    UsageModelFactory.connect(loop, stop);
    final Start loopStart = UsageModelFactory.createAddStartAction("", loopScenarioBehaviour);
    final Stop loopStop = UsageModelFactory.createAddStopAction("", loopScenarioBehaviour);
    // The branch that is contained within the loop element is created
    final org.palladiosimulator.pcm.usagemodel.Branch branch = UsageModelFactory.createBranch("", loopScenarioBehaviour);
    UsageModelFactory.connect(loopStart, branch);
    // The branch transition 1 is created
    final BranchTransition branchTransition1 = BranchWithinLoopReference.createBranchTransition(2, repositoryLookupModel, branch, correspondenceModel);
    // The branch transition 2 is created
    final BranchTransition branchTransition2 = BranchWithinLoopReference.createBranchTransition(3, repositoryLookupModel, branch, correspondenceModel);
    final OperationSignature operationSignature = CorrespondenceUtility.findModelElementForOperation(correspondenceModel, Repository.class, ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4]);
    if (operationSignature != null) {
        final EntryLevelSystemCall entryLevelSystemCall = UsageModelFactory.createEntryLevelSystemCall(repositoryLookupModel, operationSignature);
        UsageModelFactory.addUserAction(loopScenarioBehaviour, entryLevelSystemCall);
        UsageModelFactory.connect(branch, entryLevelSystemCall);
        UsageModelFactory.connect(entryLevelSystemCall, loopStop);
    }
    // User sessions according to the reference usage model are created. Thereby, it must be
    // ensured that each iteration of the branch the branch probabilities stay the same because
    // the branch is iterated. This can be achieved by an equal number of user sessions for each
    // branch transition at each iteration of the branch
    int countOfCallEvent3 = 0;
    int countOfCallEvent4 = 0;
    int entryTime = 1;
    int exitTime = 2;
    boolean branchDecision = false;
    // At each iteration the user sessions are distributed equally between the branch
    // transitions to ensure that the probabilities of the branch transitions stay equally
    final Map<Integer, List<List<UserSession>>> userSessionGroups = new HashMap<>();
    final List<List<UserSession>> startList = new ArrayList<>();
    startList.add(entryCallSequenceModel.getUserSessions());
    userSessionGroups.put(0, startList);
    // The loop that contains the branch
    for (int j = 0; j < numberOfLoops; j++) {
        countOfCallEvent3 = 0;
        countOfCallEvent4 = 0;
        final List<List<UserSession>> newUserSessionGroups = new ArrayList<>();
        // Ensures that the user sessions distribution stays equally
        for (int k = 0; k < userSessionGroups.get(j).size(); k++) {
            for (int i = 0; i < 2; i++) {
                final List<UserSession> userSessions = new ArrayList<>();
                newUserSessionGroups.add(userSessions);
            }
            final int indexGroupCallEvent3 = newUserSessionGroups.size() - 2;
            final int indexGroupCallEvent4 = newUserSessionGroups.size() - 1;
            for (int i = 0; i < userSessionGroups.get(j).get(k).size(); i++) {
                if (newUserSessionGroups.get(indexGroupCallEvent3).size() > newUserSessionGroups.get(indexGroupCallEvent4).size()) {
                    branchDecision = false;
                } else {
                    branchDecision = true;
                }
                // The branch within the loop
                if (branchDecision) {
                    BranchWithinLoopReference.createEntryCall(entryTime, exitTime, 2, k, j, i, userSessionGroups, newUserSessionGroups, indexGroupCallEvent3);
                    countOfCallEvent3++;
                    entryTime += 2;
                    exitTime += 2;
                } else {
                    BranchWithinLoopReference.createEntryCall(entryTime, exitTime, 3, k, j, i, userSessionGroups, newUserSessionGroups, indexGroupCallEvent4);
                    countOfCallEvent4++;
                    entryTime += 2;
                    exitTime += 2;
                }
                final EntryCallEvent entryCallEvent5 = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4], ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], String.valueOf(i), "hostname");
                userSessionGroups.get(j).get(k).get(i).add(entryCallEvent5, true);
                entryTime -= 2;
                exitTime -= 2;
            }
        }
        userSessionGroups.put(j + 1, newUserSessionGroups);
        entryTime += 2;
        exitTime += 2;
    }
    // Sets the likelihoods of branch transitions
    final double likelihoodOfCallEvent3 = (double) countOfCallEvent3 / (double) numberOfConcurrentUsers;
    final double likelihoodOfCallEvent4 = (double) countOfCallEvent4 / (double) numberOfConcurrentUsers;
    branchTransition1.setBranchProbability(likelihoodOfCallEvent3);
    branchTransition2.setBranchProbability(likelihoodOfCallEvent4);
    // Saves the reference usage model and sets the usage model and the EntryCallSequenceModel
    // as the reference elements. Our approach is now executed with the EntryCallSequenceModel
    // and the resulting usage model can be matched against the reference usage model
    TestHelper.saveModel(usageModel, referenceUsageModelFileName);
    testElements.setEntryCallSequenceModel(entryCallSequenceModel);
    testElements.setUsageModel(usageModel);
    return testElements;
}

Example 2 with ReferenceElements

use of org.iobserve.analysis.test.userbehavior.ReferenceElements in project iobserve-analysis by research-iobserve.

the class LoopWithinBranchReference method getModel.

/**
 * It creates a reference usage model that contains loops within branches. Accordingly, user
 * sessions whose call sequences differ from each other at the positions of the branches and
 * that contain iterated call sequences are created.(RQ-1.6)
 *
 * @param referenceUsageModelFileName
 *            file name of the reference model to store its result
 * @param repositoryLookupModel
 *            repository lookup model
 * @param correspondenceModel
 *            correspondence model
 *
 * @return a reference model and corresponding user sessions
 * @throws IOException
 *             on error
 */
public static ReferenceElements getModel(final String referenceUsageModelFileName, final RepositoryLookupModelProvider repositoryLookupModel, final CorrespondenceModel correspondenceModel) throws IOException {
    // Create a random number of user sessions and random model element parameters. The user
    // sessions' behavior will be created according to the reference usage model and
    // subsequently the user sessions are used to create a usage model. The created usage model
    // is matched against the reference usage model. The minimum number of user sessions is set
    // dependently from the random number of branch transitions, because it must be ensured that
    // each branch transition is represented within the user sessions.
    final int numberOfBranchTransitions = TestHelper.getRandomInteger(3, 2);
    final int numberOfConcurrentUsers = TestHelper.getRandomInteger(30, 10 * numberOfBranchTransitions);
    final int lengthOfBranchSequence = TestHelper.getRandomInteger(2, 1);
    final int countOfLoop = TestHelper.getRandomInteger(3, 2);
    final UserSessionCollectionModel entryCallSequenceModel = new UserSessionCollectionModel(TestHelper.getUserSessions(numberOfConcurrentUsers));
    final ReferenceElements referenceElements = new ReferenceElements();
    // In the following the reference usage model is created
    final UsageModel usageModel = UsageModelFactory.createUsageModel();
    final UsageScenario usageScenario = UsageModelFactory.createUsageScenario("", usageModel);
    final ScenarioBehaviour scenarioBehaviour = usageScenario.getScenarioBehaviour_UsageScenario();
    // lastAction = start;
    final Branch branch = LoopWithinBranchReference.createBranch(repositoryLookupModel, scenarioBehaviour, correspondenceModel, numberOfBranchTransitions, lengthOfBranchSequence, countOfLoop);
    // According to the reference usage model user sessions are created that exactly represent
    // the user behavior of the reference usage model. The entry and exit times enable that the
    // calls within the user sessions are ordered according to the reference usage model. The
    // branch transition counter ensures that each branch transition is represnted within the
    // user sessions
    final List<Integer> branchTransitionCounter = new ArrayList<>();
    boolean areAllBranchesVisited = true;
    do {
        for (int i = 0; i < branch.getBranchTransitions_Branch().size(); i++) {
            branchTransitionCounter.add(i, 0);
        }
        int entryTime = 1;
        for (int i = 0; i < entryCallSequenceModel.getUserSessions().size(); i++) {
            entryTime = 1;
            // Each user session represents one of the branch transitions
            final int branchDecisioner = TestHelper.getRandomInteger(numberOfBranchTransitions - 1, 0);
            if (branchDecisioner == 0) {
                entryTime = LoopWithinBranchReference.createLoop(branchTransitionCounter, entryTime, 0, 1, entryCallSequenceModel, lengthOfBranchSequence, countOfLoop, i);
            } else if (branchDecisioner == 1) {
                entryTime = LoopWithinBranchReference.createLoop(branchTransitionCounter, entryTime, 1, 2, entryCallSequenceModel, lengthOfBranchSequence, countOfLoop, i);
            } else if (branchDecisioner == 2) {
                entryTime = LoopWithinBranchReference.createLoop(branchTransitionCounter, entryTime, 2, 0, entryCallSequenceModel, lengthOfBranchSequence, countOfLoop, i);
            }
        }
        // It is checked whether all branch transitions are represented within the user sessions
        for (int i = 0; i < branchTransitionCounter.size(); i++) {
            if (branchTransitionCounter.get(i) == 0) {
                areAllBranchesVisited = false;
                break;
            }
        }
    } while (!areAllBranchesVisited);
    // Sets the likelihoods of the branch transitions according to the created user sessions
    for (int i = 0; i < branch.getBranchTransitions_Branch().size(); i++) {
        branch.getBranchTransitions_Branch().get(i).setBranchProbability((double) branchTransitionCounter.get(i) / (double) numberOfConcurrentUsers);
    }
    // Saves the reference usage model and sets the usage model and the EntryCallSequenceModel
    // as the reference elements. Our approach is now executed with the EntryCallSequenceModel
    // and the resulting usage model can be matched against the reference usage model
    TestHelper.saveModel(usageModel, referenceUsageModelFileName);
    referenceElements.setEntryCallSequenceModel(entryCallSequenceModel);
    referenceElements.setUsageModel(usageModel);
    return referenceElements;
}

Example 3 with ReferenceElements

use of org.iobserve.analysis.test.userbehavior.ReferenceElements in project iobserve-analysis by research-iobserve.

the class OverlappingIterationReference method getModel.

/**
 * Creates a reference model that contains a loop element. The user sessions contain iterated
 * call sequences that share overlapping calls. Thereby, one iterated sequence consists of more
 * calls than the other. Thus, it can be checked whether the approach transforms the iterated
 * call sequence that consists of more calls to a loop (RQ-1.4)
 *
 * @param referenceUsageModelFileName
 *            file name of the reference model to store its result
 * @param repositoryLookupModelProvider
 *            repository model provider
 * @param correspondenceModel
 *            correspondence model
 *
 * @return a reference usage model and corresponding user sessions
 * @throws IOException
 *             on error
 */
public static ReferenceElements getModel(final String referenceUsageModelFileName, final RepositoryLookupModelProvider repositoryLookupModelProvider, final CorrespondenceModel correspondenceModel) throws IOException {
    // Creates a random number of user sessions and random model element parameters. The user
    // sessions' behavior will be created according to the reference usage model and
    // subsequently the user sessions are used to create a usage model. The created usage model
    // is matched against the reference usage model.
    final int numberOfConcurrentUsers = TestHelper.getRandomInteger(200, 1);
    // One of the iterated sequences is iterated twice and one is iterated three times. The
    // number of iterations is set randomly.
    final int loopCount1 = TestHelper.getRandomInteger(3, 2);
    final int lengthOfSequence1 = 2 * loopCount1;
    final int loopCount2;
    if (loopCount1 == 3) {
        loopCount2 = 2;
    } else {
        loopCount2 = 3;
    }
    final int lengthOfSequence2 = 2 * loopCount2;
    final ReferenceElements referenceElements = new ReferenceElements();
    final UserSessionCollectionModel entryCallSequenceModel = new UserSessionCollectionModel(TestHelper.getUserSessions(numberOfConcurrentUsers));
    // In the following the reference usage model is created
    AbstractUserAction lastAction;
    final UsageModel usageModel = UsageModelFactory.createUsageModel();
    final UsageScenario usageScenario = UsageModelFactory.createUsageScenario("", usageModel);
    final ScenarioBehaviour scenarioBehaviour = usageScenario.getScenarioBehaviour_UsageScenario();
    final Start start = UsageModelFactory.createStart("");
    UsageModelFactory.addUserAction(scenarioBehaviour, start);
    final Stop stop = UsageModelFactory.createStop("");
    UsageModelFactory.addUserAction(scenarioBehaviour, stop);
    // According to the randomly set number of iterations the sequence that is iterated three
    // times is represented by a loop element. The other sequence is represented by a sequence
    final Loop loop = UsageModelFactory.createLoop("", scenarioBehaviour);
    if (lengthOfSequence1 >= lengthOfSequence2) {
        UsageModelFactory.connect(start, loop);
        final PCMRandomVariable pcmLoopIteration = CoreFactory.eINSTANCE.createPCMRandomVariable();
        pcmLoopIteration.setSpecification(String.valueOf(loopCount1));
        // Set number of loops
        loop.setLoopIteration_Loop(pcmLoopIteration);
        final Start loopStart = UsageModelFactory.createStart("");
        UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), loopStart);
        final Stop loopStop = UsageModelFactory.createStop("");
        UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), loopStop);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 0, loopStart, scenarioBehaviour);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 2, lastAction, scenarioBehaviour);
        UsageModelFactory.connect(lastAction, loopStop);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 3, loop, scenarioBehaviour);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 2, lastAction, scenarioBehaviour);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 3, lastAction, scenarioBehaviour);
        UsageModelFactory.connect(lastAction, stop);
    } else {
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 0, start, scenarioBehaviour);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 2, lastAction, scenarioBehaviour);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 0, lastAction, scenarioBehaviour);
        UsageModelFactory.connect(lastAction, loop);
        final PCMRandomVariable pcmLoopIteration = CoreFactory.eINSTANCE.createPCMRandomVariable();
        pcmLoopIteration.setSpecification(String.valueOf(loopCount2));
        // Set number of loops
        loop.setLoopIteration_Loop(pcmLoopIteration);
        final Start loopStart = UsageModelFactory.createStart("");
        UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), loopStart);
        final Stop loopStop = UsageModelFactory.createStop("");
        UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), loopStop);
        lastAction = loopStart;
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 2, lastAction, scenarioBehaviour);
        lastAction = OverlappingIterationReference.createEntryLevelSystemCall(repositoryLookupModelProvider, correspondenceModel, 3, lastAction, scenarioBehaviour);
        UsageModelFactory.connect(lastAction, loopStop);
        UsageModelFactory.connect(loop, stop);
    }
    OverlappingIterationReference.createMatchingEntryAndExitEvents(entryCallSequenceModel, lengthOfSequence1, lengthOfSequence2, loopCount1, loopCount2);
    // Saves the reference usage model and sets the usage model and the EntryCallSequenceModel
    // as the reference elements. Our approach is now executed with the EntryCallSequenceModel
    // and the resulting usage model can be matched against the reference usage model
    TestHelper.saveModel(usageModel, referenceUsageModelFileName);
    referenceElements.setEntryCallSequenceModel(entryCallSequenceModel);
    referenceElements.setUsageModel(usageModel);
    return referenceElements;
}

Example 4 with ReferenceElements

use of org.iobserve.analysis.test.userbehavior.ReferenceElements in project iobserve-analysis by research-iobserve.

the class CallSequenceScalabilityReferenceHelper method getModel.

/**
 * It creates a fixed number of user sessions. The number of calls per user session is
 * determined by the passed numberOfIterations parameter. It defines how often a fixed call
 * sequence is added to the call sequence of each user session. It is used to evaluate the
 * approach's response times with an increasing number of calls (RQ-3.2). It returns user
 * session that are used to execute the approach and to measure the response time. Thereby, this
 * method is called repeatedly to constantly increase the number of calls per UserSession.
 *
 * @param numberOfIterations
 *            defines how many calls per user session are created
 * @return user sessions
 */
public static ReferenceElements getModel(final int numberOfIterations) {
    final ReferenceElements testElements = new ReferenceElements();
    final int numberOfUserSessions = 50;
    final UserSessionCollectionModel entryCallSequenceModel = new UserSessionCollectionModel(TestHelper.getUserSessions(numberOfUserSessions));
    boolean branchDecisionerUserGroup1 = true;
    boolean branchDecisionerUserGroup2 = true;
    for (int i = 0; i < entryCallSequenceModel.getUserSessions().size(); i++) {
        final double userGroupDecisioner = (double) i / (double) numberOfUserSessions;
        int entryTime = 1;
        int exitTime = 2;
        // by their operation signatures
        if (userGroupDecisioner < 0.3) {
            branchDecisionerUserGroup1 = !branchDecisionerUserGroup1;
            // each user session is iterated and thus the number of calls per user session
            for (int j = 0; j < numberOfIterations; j++) {
                // One single call
                EntryCallEvent entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[0], ReferenceUsageModelBuilder.CLASS_SIGNATURE[0], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
                // An iterated call to represent a loop
                entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[1], ReferenceUsageModelBuilder.CLASS_SIGNATURE[1], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
                entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[1], ReferenceUsageModelBuilder.CLASS_SIGNATURE[1], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
                // Alternative calls to represent a branch
                final int branchDecisioner = TestHelper.getRandomInteger(2, 1);
                if (branchDecisioner == 1) {
                    entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[0], ReferenceUsageModelBuilder.CLASS_SIGNATURE[0], String.valueOf(i), "hostname");
                    entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                    entryTime += 2;
                    exitTime += 2;
                } else {
                    entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[1], ReferenceUsageModelBuilder.CLASS_SIGNATURE[1], String.valueOf(i), "hostname");
                    entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                    entryTime += 2;
                    exitTime += 2;
                }
                // An equal call to merge the branch transitions
                entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[2], ReferenceUsageModelBuilder.CLASS_SIGNATURE[2], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
            }
        } else {
            branchDecisionerUserGroup2 = !branchDecisionerUserGroup2;
            // each user session is iterated and thus the number of calls per user session
            for (int j = 0; j < numberOfIterations; j++) {
                // One single call
                EntryCallEvent entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[3], ReferenceUsageModelBuilder.CLASS_SIGNATURE[3], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
                // An iterated call to represent a loop
                entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4], ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
                entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4], ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
                // Alternative calls to represent a branch
                final int branchDecisioner = TestHelper.getRandomInteger(2, 1);
                if (branchDecisioner == 1) {
                    entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[3], ReferenceUsageModelBuilder.CLASS_SIGNATURE[3], String.valueOf(i), "hostname");
                    entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                    entryTime += 2;
                    exitTime += 2;
                } else {
                    entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4], ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], String.valueOf(i), "hostname");
                    entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                    entryTime += 2;
                    exitTime += 2;
                }
                // An equal call to merge the branch transitions
                entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[0], ReferenceUsageModelBuilder.CLASS_SIGNATURE[0], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime += 2;
                exitTime += 2;
            }
        }
    }
    // Returns the created user sessions. Now our approach can be executed and the response
    // times can be measured
    testElements.setEntryCallSequenceModel(entryCallSequenceModel);
    return testElements;
}

Example 5 with ReferenceElements

use of org.iobserve.analysis.test.userbehavior.ReferenceElements in project iobserve-analysis by research-iobserve.

the class LoopWithinLoopReference method getLoopWithinLoopReferenceModel.

/**
 * It creates a reference usage model that contains loops within loops. Accordingly, user
 * sessions whose call sequences contain iterated segments that again contain iterated segments
 * are created.(RQ-1.7)
 *
 * @param referenceUsageModelFileName
 *            file name of the reference model to store its result
 * @param repositoryLookupModel
 *            repository model provider
 * @param correspondenceModel
 *            correspondence model
 *
 * @return reference usage model and corresponding user sessions
 * @throws IOException
 *             on error
 */
public ReferenceElements getLoopWithinLoopReferenceModel(final String referenceUsageModelFileName, final RepositoryLookupModelProvider repositoryLookupModel, final CorrespondenceModel correspondenceModel) throws IOException {
    // Create a random number of user sessions and random model element parameters. The user
    // sessions' behavior will be created according to the reference usage model and
    // subsequently the user sessions are used to create a usage model. The created usage model
    // is matched against the reference usage model
    final int countOfLoop1 = TestHelper.getRandomInteger(4, 2);
    final int countOfLoop2 = TestHelper.getRandomInteger(4, 2);
    final int lengthOfSubsequentLoopSequence = TestHelper.getRandomInteger(2, 1);
    // In the following the reference usage model is created
    AbstractUserAction lastAction;
    final UsageModel usageModel = UsageModelFactory.createUsageModel();
    final UsageScenario usageScenario = UsageModelFactory.createUsageScenario("", usageModel);
    final ScenarioBehaviour scenarioBehaviour = usageScenario.getScenarioBehaviour_UsageScenario();
    final Start start = UsageModelFactory.createStart("");
    UsageModelFactory.addUserAction(scenarioBehaviour, start);
    final Stop stop = UsageModelFactory.createStop("");
    UsageModelFactory.addUserAction(scenarioBehaviour, stop);
    lastAction = start;
    // The exterior loop is created
    final Loop loop = UsageModelFactory.createLoop("", scenarioBehaviour);
    UsageModelFactory.connect(lastAction, loop);
    UsageModelFactory.connect(loop, stop);
    final PCMRandomVariable pcmLoopIteration = CoreFactory.eINSTANCE.createPCMRandomVariable();
    pcmLoopIteration.setSpecification(String.valueOf(countOfLoop1));
    loop.setLoopIteration_Loop(pcmLoopIteration);
    final Start loopStart = UsageModelFactory.createStart("");
    UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), loopStart);
    final Stop loopStop = UsageModelFactory.createStop("");
    UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), loopStop);
    lastAction = loopStart;
    // The interior loop is created
    final Loop loop2 = UsageModelFactory.createLoop("", loop.getBodyBehaviour_Loop());
    UsageModelFactory.connect(lastAction, loop2);
    final PCMRandomVariable pcmLoop2Iteration = CoreFactory.eINSTANCE.createPCMRandomVariable();
    pcmLoop2Iteration.setSpecification(String.valueOf(countOfLoop2));
    loop2.setLoopIteration_Loop(pcmLoop2Iteration);
    final Start loop2Start = UsageModelFactory.createStart("");
    UsageModelFactory.addUserAction(loop2.getBodyBehaviour_Loop(), loop2Start);
    final Stop loop2Stop = UsageModelFactory.createStop("");
    UsageModelFactory.addUserAction(loop2.getBodyBehaviour_Loop(), loop2Stop);
    lastAction = loop2Start;
    final OperationSignature operationSignature = CorrespondenceUtility.findModelElementForOperation(correspondenceModel, Repository.class, ReferenceUsageModelBuilder.CLASS_SIGNATURE[2], ReferenceUsageModelBuilder.OPERATION_SIGNATURE[2]);
    if (operationSignature != null) {
        final EntryLevelSystemCall entryLevelSystemCall = UsageModelFactory.createEntryLevelSystemCall(repositoryLookupModel, operationSignature);
        UsageModelFactory.addUserAction(loop2.getBodyBehaviour_Loop(), entryLevelSystemCall);
        UsageModelFactory.connect(lastAction, entryLevelSystemCall);
        lastAction = entryLevelSystemCall;
    }
    UsageModelFactory.connect(lastAction, loop2Stop);
    lastAction = loop2;
    // The sequence that exclusively belongs to the exterior loop is created
    for (int i = 0; i < lengthOfSubsequentLoopSequence; i++) {
        final OperationSignature operationSignature2;
        switch(i) {
            case 0:
                operationSignature2 = CorrespondenceUtility.findModelElementForOperation(correspondenceModel, Repository.class, ReferenceUsageModelBuilder.CLASS_SIGNATURE[3], ReferenceUsageModelBuilder.OPERATION_SIGNATURE[3]);
                break;
            case 1:
                operationSignature2 = CorrespondenceUtility.findModelElementForOperation(correspondenceModel, Repository.class, ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4]);
                break;
            default:
                throw new IllegalArgumentException("Illegal value of model element parameter");
        }
        if (operationSignature2 != null) {
            final EntryLevelSystemCall entryLevelSystemCall = UsageModelFactory.createEntryLevelSystemCall(repositoryLookupModel, operationSignature2);
            UsageModelFactory.addUserAction(loop.getBodyBehaviour_Loop(), entryLevelSystemCall);
            UsageModelFactory.connect(lastAction, entryLevelSystemCall);
            lastAction = entryLevelSystemCall;
        }
    }
    UsageModelFactory.connect(lastAction, loopStop);
    final int numberOfConcurrentUsers = TestHelper.getRandomInteger(200, 1);
    final UserSessionCollectionModel entryCallSequenceModel = new UserSessionCollectionModel(TestHelper.getUserSessions(numberOfConcurrentUsers));
    // According to the reference usage model user sessions are created that exactly represent
    // the user behavior of the reference usage model. The entry and exit times enable that the
    // calls within the user sessions are ordered according to the reference usage model.
    int entryTime = 1;
    int exitTime = 2;
    for (int i = 0; i < entryCallSequenceModel.getUserSessions().size(); i++) {
        entryTime = 1;
        exitTime = 2;
        // Represents the exterior loop of the reference usage model
        for (int k = 0; k < countOfLoop1; k++) {
            // Represents the interior loop of the reference usage model
            for (int j = 0; j < countOfLoop2; j++) {
                final EntryCallEvent entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[2], ReferenceUsageModelBuilder.CLASS_SIGNATURE[2], String.valueOf(i), "hostname");
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime = entryTime + 2;
                exitTime = exitTime + 2;
            }
            // Calls of the exterior loop
            for (int j = 0; j < lengthOfSubsequentLoopSequence; j++) {
                EntryCallEvent entryCallEvent = null;
                switch(j) {
                    case 0:
                        entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[3], ReferenceUsageModelBuilder.CLASS_SIGNATURE[3], String.valueOf(i), "hostname");
                        break;
                    case 1:
                        entryCallEvent = new EntryCallEvent(entryTime, exitTime, ReferenceUsageModelBuilder.OPERATION_SIGNATURE[4], ReferenceUsageModelBuilder.CLASS_SIGNATURE[4], String.valueOf(i), "hostname");
                        break;
                    default:
                        throw new IllegalArgumentException("Illegal value of model element parameter");
                }
                entryCallSequenceModel.getUserSessions().get(i).add(entryCallEvent, true);
                entryTime = entryTime + 2;
                exitTime = exitTime + 2;
            }
        }
    }
    // Saves the reference usage model and sets the usage model and the EntryCallSequenceModel
    // as the reference elements. Our approach is now executed with the EntryCallSequenceModel
    // and the resulting usage model can be matched against the reference usage model
    final ReferenceElements referenceElements = new ReferenceElements();
    TestHelper.saveModel(usageModel, referenceUsageModelFileName);
    referenceElements.setEntryCallSequenceModel(entryCallSequenceModel);
    referenceElements.setUsageModel(usageModel);
    return referenceElements;
}