fixup! Substitute identity hash codes with those that existed on the …

…first object creation

bootstrap/src/sun/nio/ch/lincheck/Injections.java

@@ -293,11 +293,21 @@ public static void beforeNewObjectCreation(String className) {
     public static void afterNewObjectCreation(Object obj) {
         getEventTracker().afterNewObjectCreation(obj);
     }
-
+
+    /**
+     * Retrieves the next object id, used for identity hash code substitution, and then advances it by one.
+     */
     public static long getNextObjectId() {
         return getEventTracker().getNextObjectId();
     }
-
+
+    /**
+     * Ensures that for the same old id, previously received with {@code getNextObjectId},
+     * the counter after calling the function persists.
+     * <p> 
+     * If for given {@code oldId} there is no saved {@code newId}, the function saves the current value.
+     * If for given {@code oldId} there is a saved {@code newId}, the function sets the counter to the {@code newId}.
+     */
     public static void advanceCurrentObjectIdWithKnownOldObjectId(long oldId) {
         getEventTracker().advanceCurrentObjectIdWithKnownOldObjectId(oldId);
     }

src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/ObjectInitialHashCodes.kt

@@ -16,6 +16,7 @@ import java.util.concurrent.atomic.AtomicLong
 
 
 private typealias Id = Long
+
 /**
  * This class stores initial identity hashcodes of created objects.
  * When the program is rerun the firstly calculated hashcodes are left as is and used to
@@ -47,43 +48,29 @@ internal class ObjectInitialHashCodes {
             currentObjectId,
             System.identityHashCode(obj)
         )
-        if (isLoggingEnabled()) {
-            println(obj::class.simpleName)
-            println(currentObjectId)
-            println(initialIdentityHashCode)
-        }
         // TODO: bizarre and crazy code below (might not work for all JVM implementations)
         UnsafeHolder.UNSAFE.putInt(obj, IDENTITY_HASHCODE_OFFSET, initialIdentityHashCode)
 
         return currentObjectId
     }
 
-    private fun isLoggingEnabled(): Boolean = System.getProperty("lincheck.log", "false") == "true"
-
     /**
      * Resets ids numeration and starts them from 0.
      */
     fun resetObjectIds() {
-        if (isLoggingEnabled()) {
-            println("Restart counter")
-        }
         nextObjectId.set(0)
     }
-
+
+    /**
+     * Ensures that for the same old id, previously received with {@code getNextObjectId},
+     * the counter after calling the function persists.
+     * <p>
+     * If for given {@code oldId} there is no saved {@code newId}, the function saves the current value.
+     * If for given {@code oldId} there is a saved {@code newId}, the function sets the counter to the {@code newId}.
+     */
     fun advanceCurrentObjectIdWithKnownOldObjectId(oldObjectId: Id) {
         val newObjectId = nextObjectId.get()
         val existingAdvance = objectIdAdvances.putIfAbsent(oldObjectId, newObjectId)
-        if (isLoggingEnabled()) {
-            print("Advancing counter: ")
-            print(oldObjectId)
-            print(" -> ")
-            if (existingAdvance != null) {
-                print("(reuse) ")
-                println(existingAdvance)
-            } else {
-                println(newObjectId)
-            }
-        }
         if (existingAdvance != null) {
             nextObjectId.set(existingAdvance)
         }

src/jvm/test/org/jetbrains/kotlinx/lincheck_test/traceDebugger/AbstractNativeCallTest.kt

@@ -21,6 +21,9 @@ import org.junit.Test
 import java.io.ByteArrayOutputStream
 import java.io.PrintStream
 
+/**
+ * Checks for absence of non-determinism and absence (or existence) of exceptions.
+ */
 abstract class AbstractNativeCallTest {
     private fun testTraceDebugger() {
         val oldStdOut = System.out