publication example code

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/systemrules/TsDataConflictSystemRule.scala

+package de.tudresden.inf.st.crme.rules.systemrules
+
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.core.ModelElementLists
+import org.rosi_project.model_management.sync.conflict.systemrules.{DataConflictSystemRule, SystemRule}
+import org.rosi_project.model_management.sync.lock._
+import org.slf4j.LoggerFactory
+
+/**
+ * Data-conflict-system-rule which integrates the data-version mechanism.
+ */
+@SystemRule("data")
+class TsDataConflictSystemRule extends DataConflictSystemRule {
+
+  val logger = LoggerFactory.getLogger(classOf[TsDataConflictSystemRule])
+
+  def getRuleName() = "TsDataConflictSystemRule"
+
+  def resolveModificationConflicts(ts: Int, modifier: String, guid: String, elementKey: String): (Boolean, PlayerSync) = {
+
+    val elementSet: Set[SynchronizationAware] = ModelElementLists.getDirectElementsFromType(elementKey)
+
+    elementSet.foreach { elem =>
+      val playerSync: SynchronizationAware = elem.asInstanceOf[SynchronizationAware]
+
+      // check for conflicts
+      if (playerSync.guid == guid) {
+        if (playerSync.deleted) {
+          logger.error("Detected deleted element in ModelElementsList ... this should not occur!")
+        }
+        // check if mod-mod-conflict
+        if (playerSync.ts > ts) {
+          logger.error("TS-Rule detected conflict (MOD-MOD): " + guid)
+          return (false, playerSync)
+        } else {
+          logger.info("TS-Rule passed by " + guid)
+          return (true, playerSync)
+        }
+      }
+    }
+    logger.error("TS-Rule detected conflict (DEL-MOD): " + guid)
+    (false, null)
+  }
+
+  def resolveDeletionConflicts(ts: Int, modifier: String, guid: String, elementKey: String): (Boolean, PlayerSync) = {
+
+    val elementSet: Set[SynchronizationAware] = ModelElementLists.getDirectElementsFromType(elementKey)
+
+    elementSet.foreach { elem =>
+      val playerSync: SynchronizationAware = elem.asInstanceOf[SynchronizationAware]
+
+      if (playerSync.guid == guid) {
+        if (playerSync.deleted) {
+          logger.error("Detected deleted element in ModelElementsList ... this should not occur!")
+        }
+        // check if mod-del-conflict
+        if (playerSync.ts > (ts * (-1))) {
+          logger.error("TS-Rule detected conflict (MOD-DEL): " + guid)
+          return (false, playerSync)
+        } else {
+          logger.info("TS-Rule passed by " + guid)
+          return (true, playerSync)
+        }
+      }
+    }
+    logger.error("TS-Rule detected conflict (DEL-DEL): " + guid)
+    (false, null)
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/systemrules/TsReferenceConflictSystemRule.scala

+package de.tudresden.inf.st.crme.rules.systemrules
+
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.core.ModelElementLists
+import org.rosi_project.model_management.sync.conflict.systemrules.{ReferenceConflictSystemRule, SystemRule}
+import org.rosi_project.model_management.sync.lock._
+import org.slf4j.LoggerFactory
+
+/**
+ * Reference-conflict-system-rule which integrates the reference-version mechanism.
+ */
+@SystemRule("reference")
+class TsReferenceConflictSystemRule extends ReferenceConflictSystemRule {
+
+  val logger = LoggerFactory.getLogger(classOf[TsReferenceConflictSystemRule])
+
+  def getRuleName() = "TsReferenceConflictSystemRule"
+
+  def resolveDeletedReferencedElementConflicts(guid: String, elementKey: String): PlayerSync = {
+
+    val elementSet: Set[SynchronizationAware] = ModelElementLists.getDirectElementsFromType(elementKey)
+
+    elementSet.foreach { elem =>
+      val playerSync: SynchronizationAware = elem.asInstanceOf[SynchronizationAware]
+
+      // check for conflicts
+      if (playerSync.guid == guid) {
+        if (playerSync.deleted) {
+          logger.warn("Detected deleted element in ModelElementsList ... this should not occur!")
+        } else {
+          return playerSync
+        }
+      }
+    }
+    logger.info("Detected ref-conflict (ADD-REF/DEL-REF): " + guid)
+    null
+  }
+
+  def resolveDeletedReferencingElementConflicts(guid: String, elementKey: String): PlayerSync = {
+
+    val elementSet: Set[SynchronizationAware] = ModelElementLists.getDirectElementsFromType(elementKey)
+
+    elementSet.foreach { elem =>
+      val playerSync: SynchronizationAware = elem.asInstanceOf[SynchronizationAware]
+
+      if (playerSync.guid == guid) {
+        if (playerSync.deleted) {
+          logger.warn("Detected deleted element in ModelElementsList ... this should not occur!")
+        } else {
+          return playerSync
+        }
+      }
+    }
+    logger.error("Detected ref-conflict (REF-MOD-DEL/REF-MOD-ADD): " + guid)
+    null
+  }
+
+  @deprecated
+  def resolveReferenceCounterConflicts(rv: Int, referencingElement: PlayerSync): Boolean = {
+    // reason for 2nd condition: initially the ref-version of a new element is set to 1
+    return rv == referencingElement.rv || (rv == 0 && referencingElement.rv == 1)
+  }
+}

crm-example/src/test/java/CrmConflictBenchmark.scala

+import de.tudresden.inf.st.crme.models.MetaModels
+import de.tudresden.inf.st.crme.models.modelB.Team
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import de.tudresden.inf.st.crme.rsync.compartments.{CrmModelsConstructionCompartment, CrmModelsDestructionCompartment, CrmModelsSyncCompartment}
+import de.tudresden.inf.st.crme.rsync.constants.ModelConstants
+import de.tudresden.inf.st.crme.rules.customrules.{MemberCustomDeletionRule, MemberCustomReferenceCreationRule, MemberCustomReferenceDeletionRule}
+import de.tudresden.inf.st.crme.rules.systemrules.{OwnerDataConflictSystemRule, TsDataConflictSystemRule, TsReferenceConflictSystemRule}
+import org.junit.jupiter.api.{BeforeAll, BeforeEach, Test}
+import org.rosi_project.model_management.{ClientChangeRecord, ConflictResolution, ConflictResolutionResponse}
+import org.rosi_project.model_management.core.{ModelElementLists, SynchronizationCompartment}
+import org.rosi_project.model_management.sync.conflict.customrules.CustomRuleExecutor
+import org.rosi_project.model_management.sync.conflict.systemrules.SystemRuleExecutor
+import org.rosi_project.model_management.sync.procedures.data.ClientEntireRecord
+import org.rosi_project.model_management.util.{PerformanceCounter, PerformanceInformation}
+import org.slf4j.{Logger, LoggerFactory}
+import org.testng.annotations.BeforeClass
+import scroll.internal.Compartment
+
+import java.util.concurrent.{Callable, Executors}
+import scala.collection.mutable.ListBuffer
+import scala.sys.error
+
+class CrmConflictBenchmark {
+  val log: Logger = LoggerFactory.getLogger(getClass)
+
+  @BeforeEach
+  def init(): Unit ={
+    MetaModels.initCrmMetaModels()
+  }
+
+  def createSimpleElements(count: Int): (ConflictResolutionResponse, Seq[String]) ={
+    // Initial creation of elements
+    val clientChangeRecords = ListBuffer[ClientChangeRecord]()
+    val clientEntireRecords = ListBuffer[ClientEntireRecord]()
+
+    for(i <- 1 to count) {
+      clientChangeRecords.append(ClientChangeRecord(ModelConstants.SIMPLE_EMPLOYEE_MODEL_TYPE, s"e${i} t${Thread.currentThread().getId}", 0, 0,
+        Map("birthday" -> "01.01.1995", "fullName" -> s"Member ${i}", "address" -> "Dresden"), Map(), Map(), s"e${i} t${Thread.currentThread().getId}", s"testuser${Thread.currentThread().getId}", refonly = false))
+      clientEntireRecords.append(ClientEntireRecord(s"e${i} t${Thread.currentThread().getId}", 0, 0, ModelConstants.SIMPLE_EMPLOYEE_MODEL_TYPE))
+    }
+
+    val initResponse = ConflictResolution.syncModel("creation", clientChangeRecords, clientEntireRecords, count, s"testuser${Thread.currentThread().getId}")
+    val employeeGuids = initResponse.changes.filter(x => x.model == ModelConstants.SIMPLE_EMPLOYEE_MODEL_TYPE).map(x => x.guid)
+    //    val teams: Seq[Team] = for(i <- 1 to count)
+    //      yield ModelElementLists.getDirectElementsFromType(ModelConstants.TEAM_MODEL_TYPE).find(p => p.asInstanceOf[Team].getTeamName().equals(s"Team ${i}")).get.asInstanceOf[Team]
+
+    (initResponse, employeeGuids)
+  }
+
+  def createElements(count: Int, teamCount: Int): (ConflictResolutionResponse, Seq[String], Seq[String]) ={
+    // Initial creation of elements
+    val clientChangeRecords = ListBuffer[ClientChangeRecord]()
+    val clientEntireRecords = ListBuffer[ClientEntireRecord]()
+
+    for(i <- 0 until count) {
+      clientChangeRecords.append(ClientChangeRecord(ModelConstants.MEMBER_MODEL_TYPE, s"e${i} t${Thread.currentThread().getId}", 0, 0,
+        Map("birthday" -> s"${i}.01.1995", "lastName" -> s"Member ${i}", "address" -> "Dresden"), Map(), Map(), s"e${i} t${Thread.currentThread().getId}", s"testuser${Thread.currentThread().getId}", refonly = false))
+      clientEntireRecords.append(ClientEntireRecord(s"e${i} t${Thread.currentThread().getId}", 0, 0, ModelConstants.MEMBER_MODEL_TYPE))
+    }
+    for(i <- 0 until teamCount){
+      clientChangeRecords.append(ClientChangeRecord(ModelConstants.TEAM_MODEL_TYPE, s"t${i} t${Thread.currentThread().getId}", 0, 0,
+        Map("teamName" -> s"Team ${i}"), Map(), Map(), s"t${i} t${Thread.currentThread().getId}", s"testuser${Thread.currentThread().getId}", refonly = false))
+      clientEntireRecords.append(ClientEntireRecord(s"t${i} t${Thread.currentThread().getId}", 0, 0, ModelConstants.TEAM_MODEL_TYPE))
+    }
+
+    val initResponse = ConflictResolution.syncModel("creation", clientChangeRecords, clientEntireRecords, count, s"testuser${Thread.currentThread().getId}")
+    val employeeGuids = initResponse.changes.filter(x => x.model == ModelConstants.MEMBER_MODEL_TYPE).map(x => x.guid)
+    val teamGuids = initResponse.changes.filter(x => x.model == ModelConstants.TEAM_MODEL_TYPE).map(x => x.guid)
+
+    if(employeeGuids.length != count)
+      error("Employee count does not match")
+    if(teamGuids.length != teamCount)
+      error("Team count does not match")
+
+//    val teams: Seq[Team] = for(i <- 1 to count)
+//      yield ModelElementLists.getDirectElementsFromType(ModelConstants.TEAM_MODEL_TYPE).find(p => p.asInstanceOf[Team].getTeamName().equals(s"Team ${i}")).get.asInstanceOf[Team]
+
+    (initResponse, employeeGuids, teamGuids)
+  }
+
+  @Test
+  def testSimpleCreation(): Unit = {
+    MetaModels.reset()
+    createElements(1, 1)
+    ModelElementLists.printAll()
+  }
+
+  @Test
+  def testCreation(): Unit ={
+    for(m <- 1 to 2) {
+      val times = ListBuffer[PerformanceInformation]()
+      for (count <- 100 to 500 by 100) {
+        for (n <- 0 until 5) {
+          println(s"${n} ${count}")
+          MetaModels.reset()
+          val (response, _, _) = createElements(count, 0)
+          times.append(response.performance)
+        }
+      }
+      PerformanceCounter.writeRecords(times, "../../evaluation/bench_creation.csv")
+    }
+  }
+
+  def oneDeletionIteration(count: Int, threadCount: Int): PerformanceInformation = {
+    val (creationResult, employeeGuids, teamGuids) = createElements(count, 0)
+
+    val clientChangeRecords = ListBuffer[ClientChangeRecord]()
+    val clientEntireRecords = ListBuffer[ClientEntireRecord]()
+
+    val countConflicts = Math.ceil(count / 10.0).toInt
+    for (i <- 0 until count) {
+      val ts = if (i % countConflicts == 0) 3 else 2
+      clientChangeRecords.append(ClientChangeRecord(ModelConstants.MEMBER_MODEL_TYPE, employeeGuids(i), 1, -ts,
+        Map("birthday" -> "01.01.1995", "fullName" -> s"Member ${i}", "address" -> "Dresden", "salary" -> "0.0"), Map(), Map(), s"e${i} t${Thread.currentThread().getId}", s"${Thread.currentThread().getId}", refonly = false))
+      clientEntireRecords.append(ClientEntireRecord(employeeGuids(i), -ts, 1, ModelConstants.MEMBER_MODEL_TYPE))
+    }
+
+    val result = ConflictResolution.syncModel("deletion", clientChangeRecords, clientEntireRecords, count * 3, s"testuser${Thread.currentThread().getId}", threadCount)
+
+    result.performance
+  }
+
+  def oneModificationIteration(count: Int, threadCount: Int): PerformanceInformation = {
+    val clientChangeRecords = ListBuffer[ClientChangeRecord]()
+    val clientEntireRecords = ListBuffer[ClientEntireRecord]()
+    val countConflicts = Math.ceil(count / 10.0).toInt
+
+    val (creationResult, employeeGuids, teamGuids) = createElements(count, 0)
+
+    // Change elements: Some with lower ts than already registered
+    for (i <- 0 until count) {
+      val ts = if (i % countConflicts == 0) 2 else 1
+      clientChangeRecords.append(ClientChangeRecord(ModelConstants.MEMBER_MODEL_TYPE, employeeGuids(i), 1, ts,
+        Map("birthday" -> s"0${i}.01.1995", "fullName" -> s"Member ${i}", "address" -> "Dresden", "salary" -> "0"), Map(), Map(), s"e${i} t${Thread.currentThread().getId}", s"${Thread.currentThread().getId}", refonly = false))
+      clientEntireRecords.append(ClientEntireRecord(employeeGuids(i), ts, 1, ModelConstants.MEMBER_MODEL_TYPE))
+    }
+    val modificationResult = ConflictResolution.syncModel("modification", clientChangeRecords, clientEntireRecords, count * 3, s"testuser${Thread.currentThread().getId}", threadCount)
+
+    modificationResult.performance
+  }
+
+  def oneReferenceDeletionIteration(count: Int, threadCount: Int): PerformanceInformation = {
+    val countConflicts = Math.ceil(count / 10.0).toInt
+
+    val clientChangeRecords = ListBuffer[ClientChangeRecord]()
+    val clientEntireRecords = ListBuffer[ClientEntireRecord]()
+   // val clientChangeRecords2 = ListBuffer[ClientChangeRecord]()
+   // val clientEntireRecords2 = ListBuffer[ClientEntireRecord]()
+
+    val (creationResult, employeeGuids, teams) = createElements(count, count)
+
+    for(i <- 0 until count) {
+      //val rv = if (i % countConflicts == 0) 3 else 2
+      clientChangeRecords.append(ClientChangeRecord(ModelConstants.TEAM_MODEL_TYPE, teams(i), 1, 1,
+        Map(), Map(), Map("members" -> Set(employeeGuids(i))), s"Team0", s"${Thread.currentThread().getId}", refonly = false))
+  //    clientEntireRecords.append(ClientEntireRecord(employeeGuids(i), 2, 1, ModelConstants.EMPLOYEE_MODEL_TYPE))
+      clientEntireRecords.append(ClientEntireRecord(teams(i), 1, 1, ModelConstants.TEAM_MODEL_TYPE))
+
+      if (i % countConflicts == 0) {
+        clientChangeRecords.append(ClientChangeRecord(ModelConstants.TEAM_MODEL_TYPE, teams(i), 2, 1,
+          Map(), Map(), Map("members" -> Set(employeeGuids(i))), "Team0", s"${Thread.currentThread().getId}", refonly = false))
+        //clientEntireRecords.append(ClientEntireRecord(employeeGuids(i), 3, 1, ModelConstants.EMPLOYEE_MODEL_TYPE))
+        //clientEntireRecords.append(ClientEntireRecord(teamGuids(i), 3, 1, ModelConstants.TEAM_MODEL_TYPE))
+      }
+    }
+
+    val result1 = ConflictResolution.syncModel("referencedeletion", clientChangeRecords, clientEntireRecords, count * 3, s"testuser${Thread.currentThread().getId}", threadCount)
+    val r1performance = result1.performance
+
+   // val result2 = ConflictResolution.syncModel("referencedeletion", clientChangeRecords2, clientEntireRecords2)
+  //  val r2performance = result2.performance
+
+    r1performance
+   //PerformanceInformation(r2performance.thread, r2performance.lockFailures + r1performance.lockFailures, r2performance.name, r1performance.time + r2performance.time, count, r1performance.threads)
+  }
+
+  @Test
+  def testModification(): Unit ={
+    for(m <- 1 to 2) {
+      val times = ListBuffer[PerformanceInformation]()
+      for (count <- 30 to 300 by 30) {
+        println(s"${count}")
+        for (n <- 1 to 8) {
+          MetaModels.reset()
+
+          times.append(oneModificationIteration(count, 1))
+        }
+      }
+      PerformanceCounter.writeRecords(times, "../../evaluation/bench_modification.csv")
+    }
+  }
+
+  @Test
+    def testModificationParallel() {
+    val perflist = ListBuffer[PerformanceInformation]()
+    val executor = Executors.newFixedThreadPool(4)
+
+    for (threads <- 1 to 4) {
+      for (count <- 30 to 300 by 30) {
+        val m = if(threads == 1) 6 else 3
+        for (n <- 1 to m) {
+          println(s"THREADS: ${threads} COUNT: ${count} N: ${n}")
+
+          MetaModels.reset()
+
+          val run: Callable[PerformanceInformation] = () => oneModificationIteration(count, threads)
+          val futures = for (i <- 0 until threads) yield executor.submit(run)
+
+          futures.foreach { f =>
+            val perf = f.get()
+            perflist.append(perf)
+          }
+        }
+      }
+    }
+
+    PerformanceCounter.writeRecords(perflist, "../../evaluation/bench_modification_parallel.csv")
+  }
+
+  @Test
+  def testDeletion(): Unit = {
+    val times = ListBuffer[PerformanceInformation]()
+
+    for(m <- 1 to 2) {
+      for (count <- 30 to 300 by 30) {
+        for (n <- 1 to 5) {
+          println(s"COUNT: ${count} N: ${n}")
+
+          MetaModels.reset()
+          val result = oneDeletionIteration(count, 1)
+          times.append(result)
+        }
+      }
+
+    PerformanceCounter.writeRecords(times, "../../evaluation/bench_deletion.csv")
+    }
+  }
+
+  @Test
+  def testDeletionParallel(): Unit ={
+    val perflist = ListBuffer[PerformanceInformation]()
+    val executor = Executors.newFixedThreadPool(4)
+
+    for (threads <- 1 to 4) {
+      for (count <- 30 to 300 by 30) {
+        for (n <- 1 to 4) {
+          println(s"THREADS: ${threads} COUNT: ${count} N: ${n}")
+
+          MetaModels.reset()
+
+          val run: Callable[PerformanceInformation] = () => oneDeletionIteration(count, threads)
+          val futures = for (i <- 0 until threads) yield executor.submit(run)
+
+          futures.foreach { f =>
+            val perf = f.get()
+            perflist.append(perf)
+          }
+        }
+      }
+    }
+
+    PerformanceCounter.writeRecords(perflist, "../../evaluation/bench_deletion_parallel.csv")
+  }
+
+  @Test
+  def testReferenceDeletion(): Unit = {
+    for(m <- 1 to 2) {
+      val times = ListBuffer[PerformanceInformation]()
+
+      // Delete some elements: Some twice
+      for (count <- 30 to 300 by 30) {
+        for (n <- 1 to 6) {
+          println(s"COUNT: ${count} N: ${n}")
+
+          MetaModels.reset()
+
+          val performanceInformation = oneReferenceDeletionIteration(count, 1)
+          times.append(performanceInformation)
+        }
+      }
+
+      PerformanceCounter.writeRecords(times, "../../evaluation/bench_reference_deletion.csv")
+    }
+  }
+
+  @Test
+  def testParallelReferenceDeletion(): Unit = {
+    val executor = Executors.newFixedThreadPool(4)
+
+    for(m <- 1 to 2) {
+      val times = ListBuffer[PerformanceInformation]()
+
+      // Delete some elements: Some twice
+      for (threads <- 1 to 4) {
+        for (count <- 30 to 300 by 30) {
+          val iter = if(threads == 1) 8 else 5
+          for (n <- 1 to iter) {
+            println(s"THREADS: ${threads} COUNT: ${count} N: ${n}")
+
+            MetaModels.reset()
+
+            val run: Callable[PerformanceInformation] = () => oneReferenceDeletionIteration(count, threads)
+            val futures = for (i <- 0 until threads) yield executor.submit(run)
+
+            futures.foreach { f =>
+              val perf = f.get()
+              times.append(perf)
+            }
+          }
+        }
+      }
+
+      PerformanceCounter.writeRecords(times, "../../evaluation/bench_reference_deletion_parallel.csv")
+    }
+  }
+}

crm-example/src/test/java/RsyncOnlyBenchmark.scala

+import de.tudresden.inf.st.crme.models.MetaModels
+import de.tudresden.inf.st.crme.models.modelA.Employee
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import de.tudresden.inf.st.crme.rsync.constants.ModelConstants
+import org.junit.jupiter.api.{BeforeAll, BeforeEach, Test}
+import org.rosi_project.model_management.core.ModelElementLists
+import org.rosi_project.model_management.util.{PerformanceCounter, RsyncOnlyPerformanceInformation}
+
+import scala.collection.mutable.ListBuffer
+
+
+class RsyncOnlyBenchmark {
+  @BeforeEach
+  def init(): Unit ={
+    MetaModels.initCrmMetaModels()
+  }
+
+  def createElementsRsyncOnly(count: Int): Seq[Member] ={
+    MetaModels.reset()
+    val t = new Team("Team 0", null, Set(), null, "t0", "user1")
+    val employees = for(i <- 1 to count) yield new Member("01.01.1995", "Tim", "Dresden", "K", "Dresden", t, t, null, s"e${i}", "user1")
+
+    employees
+  }
+
+  @Test
+  def modificationRsyncOnly: Unit = {
+    for(j <- 1 to 2) {
+      val times = new ListBuffer[RsyncOnlyPerformanceInformation]()
+
+      for (count <- 30 to 300 by 30) {
+        val countConflicts = Math.ceil(count / 10.0).toInt
+
+        println(s"${count}")
+        val employees = createElementsRsyncOnly(count)
+
+        for (n <- 1 to 10) {
+          val start = System.nanoTime()
+          var i = 0
+          employees.foreach { e =>
+            e.setBirthday(s"0${n}.01.1995")
+            e.syncFieldsToOtherModels()
+            if(i % countConflicts == 0){
+              e.setBirthday(s"test")
+              e.syncFieldsToOtherModels()
+            }
+            i += 1
+          }
+          val duration = System.nanoTime() - start
+          times.append(RsyncOnlyPerformanceInformation("modification", duration, count * 3))
+        }
+      }
+
+      PerformanceCounter.writeRsyncRecords(times, "../../evaluation/bench_modification_rsync.csv")
+    }
+  }
+
+  @Test
+  def deletionRsyncOnly: Unit = {
+    val times = new ListBuffer[RsyncOnlyPerformanceInformation]()
+
+    for(j <- 1 to 2) {
+      for (count <- 30 to 300 by 30) {
+        println(s"${count}")
+        val employees = createElementsRsyncOnly(count)
+
+        for (n <- 1 to 8) {
+          val start = System.nanoTime()
+          employees.foreach { e =>
+            e.deleteObjectFromSynchro()
+          }
+          val duration = System.nanoTime() - start
+          times.append(RsyncOnlyPerformanceInformation("modification", duration, count * 3))
+        }
+      }
+
+      PerformanceCounter.writeRsyncRecords(times, "../../evaluation/bench_deletion_rsync.csv")
+    }
+  }
+
+  @Test
+  def referenceDeletionRsyncOnly: Unit = {
+    val times = new ListBuffer[RsyncOnlyPerformanceInformation]()
+
+    for (j <- 1 to 2) {
+      for (count <- 30 to 300 by 30) {
+        println(s"${count}")
+        val employees = createElementsRsyncOnly(count)
+
+        for (n <- 1 to 8) {
+          val start = System.nanoTime()
+          employees.foreach { e =>
+            e.setMemberInTeam(null)
+            e.syncFieldsToOtherModels()
+          }
+          val duration = System.nanoTime() - start
+          times.append(RsyncOnlyPerformanceInformation("referencedeletion", duration, count * 3))
+        }
+      }
+
+      PerformanceCounter.writeRsyncRecords(times, "../../evaluation/bench_reference_deletion_rsync.csv")
+    }
+  }
+}

crm-example/src/test/java/TestCrmSync.scala

+import de.tudresden.inf.st.crme.models.MetaModels
+import de.tudresden.inf.st.crme.models.modelA.PresenceEmployee
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import de.tudresden.inf.st.crme.rsync.compartments.{CrmModelsConstructionCompartment, CrmModelsDestructionCompartment, CrmModelsSyncCompartment}
+import de.tudresden.inf.st.crme.rsync.constants.ModelConstants
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.rosi_project.model_management.core.{ModelElementLists, SynchronizationCompartment}
+import org.rosi_project.model_management.sync.lock.{ElementLock, ElementLockProvider}
+import org.rosi_project.model_management.util.UuidUtil
+import org.slf4j.{Logger, LoggerFactory}
+import scroll.internal.Compartment
+
+class TestCrmSync {
+  val log: Logger = LoggerFactory.getLogger(getClass)
+
+  @Test
+  def testSync(){
+    new Compartment {
+      MetaModels.initCrmMetaModels()
+
+      val lock: ElementLock = ElementLockProvider.provideLockObject()
+
+      val simpleEmployee: SimpleEmployee = new SimpleEmployee("16.07.95", false, "NEWTEAM", "John Doe", "Sample Address 123", lock, UuidUtil.generateUuid(), "owner1")
+      val team = new Team("ATeam", null, Set(), lock, UuidUtil.generateUuid(), "owner1")
+      val member: Member = new Member("01.01.2001", "Max", "Headquarter", "Muster", "Sample Address 456", team, null, lock,
+        UuidUtil.generateUuid(), "owner1")
+      new PresenceEmployee("Jane Doe", "05.06.1999", "Sample Address 789", 4000.00f, lock, UuidUtil.generateUuid(), "owner1")
+
+      ElementLockProvider.removeLocks(Set(ModelConstants.MEMBER_MODEL_TYPE, ModelConstants.TEAM_MODEL_TYPE), lock.getId())
+
+      // Assert that all employees have been created as every type
+
+      val presenceEmployees: Set[PresenceEmployee] = ModelElementLists.getElementsFromType("modelA.PresenceEmployee").map(x => x.asInstanceOf[PresenceEmployee])
+      assert(presenceEmployees.exists(x => x.getFullName() == "John Doe"))
+      assert(presenceEmployees.exists(x => x.getFullName() == "Jane Doe"))
+      assert(presenceEmployees.exists(x => x.getFullName() == "Max Muster"))
+
+      val simpleEmployees: Set[SimpleEmployee] = ModelElementLists.getElementsFromType("modelC.SimpleEmployee").map(x => x.asInstanceOf[SimpleEmployee])
+      assert(simpleEmployees.exists(x => x.getFullName() == "John Doe"))
+      assert(simpleEmployees.exists(x => x.getFullName() == "Jane Doe"))
+      assert(simpleEmployees.exists(x => x.getFullName() == "Max Muster"))
+
+      val members: Set[Member] = ModelElementLists.getElementsFromType("modelB.Member").map(x => x.asInstanceOf[Member])
+      assert(members.exists(x => x.getFullName() == "John Doe"))
+      assert(members.exists(x => x.getFullName() == "Jane Doe"))
+      assert(members.exists(x => x.getFullName() == "Max Muster"))
+
+
+      // ModelElementLists.printAll()
+      // log.error("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+      simpleEmployee.setTeam("TEAM TEAM TEAM")
+      simpleEmployee.syncFieldsToOtherModels()
+
+      // assert(ModelElementLists.getElementsFromType("modelB.Member").map(x => x.asInstanceOf[Member]).exists(x => x.getMemberInTeam() != null && x.getMemberInTeam().getTeamName() == "TEAM TEAM TEAM"))
+
+      member.setFirstName("Sebastian")
+      member.syncFieldsToOtherModels()
+
+      assert(ModelElementLists.getElementsFromType("modelC.SimpleEmployee").map(x => x.asInstanceOf[SimpleEmployee]).exists(x => x.getFullName() == "Sebastian Muster"))
+
+      team.addMember(member)
+
+      assert(ModelElementLists.getElementsFromType("modelC.SimpleEmployee").map(x => x.asInstanceOf[SimpleEmployee]).exists(x => x.getTeam() != null && x.getTeam() == team.getTeamName() && x.getFullName() == "Sebastian Muster"))
+
+      //ModelElementLists.printAll()
+      //log.error("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%--")
+
+      team.deleteObjectFromSynchro()
+      member.deleteObjectFromSynchro()
+      ModelElementLists.printAll()
+
+      assert(ModelElementLists.getElementsFromType("modelB.SimpleEmployee").map(x => x.asInstanceOf[SimpleEmployee]).forall(x => !(x.getFullName() == member.getFullName())))
+
+      // log.error("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%--")
+      // assertEquals("Hello", "Hello");
+    }
+  }
+}