Draft: Add new loop detector

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

@@ -80,7 +80,7 @@ void cacheInvokeDynamicCallSite(
     void onInlineMethodCallReturn(ThreadDescriptor descriptor, int methodId);
     void onInlineMethodCallException(ThreadDescriptor descriptor, int methodId, Throwable t);
 
-    void onSnapshotLineBreakpoint(ThreadDescriptor descriptor, int codeLocation, Object[] locals);
+    void onSnapshotLineBreakpoint(ThreadDescriptor descriptor, int codeLocation, Object[] locals, String traceId);
 
     void onLoopIteration(ThreadDescriptor descriptor, int codeLocation, int loopId);
     void afterLoopExit(ThreadDescriptor descriptor, int codeLocation, int loopId, Throwable exception, boolean isReachableFromOutsideLoop);

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

@@ -297,6 +297,32 @@ public static boolean inAnalyzedCode() {
         return (descriptor != null);
     }
 
+    /**
+     * Marks the current thread as being inside a breakpoint condition evaluation.
+     */
+    public static void enterBreakpointCondition(ThreadDescriptor descriptor) {
+        if (descriptor == null) return;
+        descriptor.enterBreakpointCondition();
+    }
+
+    /**
+     * Marks the current thread as having exited a breakpoint condition evaluation.
+     */
+    public static void leaveBreakpointCondition(ThreadDescriptor descriptor) {
+        if (descriptor == null) return;
+        descriptor.leaveBreakpointCondition();
+    }
+
+    /**
+     * Checks if the current thread is not inside a breakpoint condition evaluation.
+     *
+     * @return true if not inside a condition evaluation, false otherwise.
+     */
+    public static boolean isNotInsideBreakpointCondition(ThreadDescriptor descriptor) {
+        if (descriptor == null) return true;
+        return !descriptor.isInsideBreakpointCondition();
+    }
+
     /**
      * Registers a thread for event tracking, creating a new thread descriptor if one does not already exist.
      *
@@ -784,13 +810,13 @@ public static void onMethodCallException(ThreadDescriptor descriptor, int method
      * @param descriptor   The thread descriptor of the current thread.
      * @param codeLocation The location of the breakpoint in the source code. Holds local variable names.
      * @param locals       An array containing the current values of local variables at the breakpoint location.
-     *                     This includes: this, function parameters, and local variables. 
+     *                     This includes: this, function parameters, and local variables.
+     * @param traceId      ID to correlate snapshot breakpoints. Can be provided by frameworks like OpenTelemetry.
      */
-
-    public static void onSnapshotLineBreakpoint(ThreadDescriptor descriptor, int codeLocation, Object[] locals) {
+    public static void onSnapshotLineBreakpoint(ThreadDescriptor descriptor, int codeLocation, Object[] locals, String traceId) {
         EventTracker eventTracker = getEventTracker(descriptor);
         if (eventTracker == null || descriptor == null) return;
-        eventTracker.onSnapshotLineBreakpoint(descriptor, codeLocation, locals);
+        eventTracker.onSnapshotLineBreakpoint(descriptor, codeLocation, locals, traceId);
     }
 
     /**

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

@@ -95,6 +95,12 @@ public class ThreadDescriptor {
      */
     private int ignoredSectionDepth = 0;
 
+    /**
+     * Thread-local variable to track if we are currently evaluating a breakpoint condition.
+     * When true, breakpoint hits inside the condition evaluation should not be reported.
+     */
+    private boolean insideBreakpointCondition = false;
+
     /**
      * Creates a new thread descriptor for the given thread.
      */
@@ -249,6 +255,18 @@ public void restoreIgnoredSectionDepth(int depth) {
         ignoredSectionDepth = depth;
     }
 
+    public void enterBreakpointCondition() {
+        insideBreakpointCondition = true;
+    }
+
+    public void leaveBreakpointCondition() {
+        insideBreakpointCondition = false;
+    }
+
+    public boolean isInsideBreakpointCondition() {
+        return insideBreakpointCondition;
+    }
+
     /**
      * Thread local variable storing the thread descriptor for each thread.
      * <br>

buildSrc/src/main/kotlin/TraceAgentTasks.kt

@@ -75,7 +75,16 @@ fun Project.registerTraceAgentTasks(fatJarName: String, fatJarTaskName: String,
             }
         })
         from(jarWrapper)
-
+
+        /* IMPORTANT NOTE!
+         *
+         * Shadowing will also substitute ALL strings containing package names in ALL source files;
+         * when adding a new shadowed package, use `listOf(...)` hack to circumvent package shadowing:
+         * for instance, instead of `org.objectweb.asm`, use `listOf("org", "objectweb", "asm").joinToString(".")`.
+         *
+         * To minimize the affected surface area, all package-related string checks should be extracted into
+         * separate utility functions and be kept in `common/src/main/org/jetbrains/lincheck/util/Utils.kt`.
+         */
         val packagesToShade = listOf(
             "org.objectweb.asm",
             "net.bytebuddy",

common/src/main/org/jetbrains/lincheck/descriptors/CodeLocations.kt

@@ -20,7 +20,7 @@ class CodeLocation(
     // TODO: this only makes sense for method call code locations,
     //   consider introducing proper type hierarchy for code locations
     val argumentNames: List<AccessPath?>? = null,
-    val activeLocals: List<String>? = null
+    val activeLocals: List<ActiveLocal>? = null,
 ) {
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -61,7 +61,7 @@ object CodeLocations {
         stackTraceElement: StackTraceElement,
         accessPath: AccessPath? = null,
         argumentNames: List<AccessPath?>? = null,
-        activeLocals: List<String>? = null
+        activeLocals: List<ActiveLocal>? = null
     ): Int =
         context.newCodeLocation(stackTraceElement, accessPath, argumentNames, activeLocals)
 
@@ -81,5 +81,5 @@ object CodeLocations {
 
     @JvmStatic
     @Synchronized
-    fun activeLocals(context: TraceContext, codeLocationId: Int): List<String>? = context.activeLocalsNames(codeLocationId)
+    fun activeLocals(context: TraceContext, codeLocationId: Int): List<ActiveLocal>? = context.activeLocals(codeLocationId)
 }

common/src/main/org/jetbrains/lincheck/descriptors/Descriptors.kt

@@ -65,3 +65,15 @@ data class VariableDescriptor(
     val name: String,
     val type: Types.Type
 )
+
+
+data class ActiveLocal(
+    val localName: String,
+    val localKind: LocalKind,
+)
+
+enum class LocalKind {
+    THIS,
+    PARAMETER,
+    VARIABLE,
+}

common/src/main/org/jetbrains/lincheck/trace/TraceContext.kt

@@ -11,6 +11,7 @@
 package org.jetbrains.lincheck.trace
 
 import org.jetbrains.lincheck.descriptors.AccessPath
+import org.jetbrains.lincheck.descriptors.ActiveLocal
 import org.jetbrains.lincheck.descriptors.ClassDescriptor
 import org.jetbrains.lincheck.descriptors.CodeLocation
 import org.jetbrains.lincheck.descriptors.FieldDescriptor
@@ -142,7 +143,7 @@ class TraceContext {
         stackTraceElement: StackTraceElement,
         accessPath: AccessPath? = null,
         argumentNames: List<AccessPath?>? = null,
-        activeLocals: List<String>? = null
+        activeLocals: List<ActiveLocal>? = null
     ): Int {
         val id = locations.size
         val location = CodeLocation(stackTraceElement, accessPath, argumentNames, activeLocals)
@@ -180,7 +181,7 @@ class TraceContext {
         return loc.argumentNames
     }
 
-    fun activeLocalsNames(codeLocationId: Int): List<String>? {
+    fun activeLocals(codeLocationId: Int): List<ActiveLocal>? {
         if (codeLocationId == UNKNOWN_CODE_LOCATION_ID) return null
         val loc = locations[codeLocationId] ?: error("Invalid code location id $codeLocationId")
         return loc.activeLocals

common/src/main/org/jetbrains/lincheck/util/AnalysisSections.kt

@@ -320,6 +320,11 @@ class AnalysisProfile(val analyzeStdLib: Boolean) {
             if (isThreadContainerClass(className)) return true
             return false
         }
+        // Old legacy Java std library for CORBA,
+        // for instance, `org/omg/stub/javax/management`;
+        // can appear on Java 8 when JMX is used.
+        if (className.startsWith("org.omg.")) return false
+
         // We do not need to instrument most standard Kotlin classes.
         // However, we need to inject the Lincheck analysis into the classes
         // related to collections, iterators, random and coroutines.
@@ -346,23 +351,23 @@ class AnalysisProfile(val analyzeStdLib: Boolean) {
         if (isIntellijRuntimeAgentClass(className)) return false
         // We should never instrument the JetBrains coverage package classes (for instance, relocated ASM library).
         if (isJetBrainsCoverageClass(className)) return false
+
+        // Do not instrument bytecode-manipulation libraries
+        // (special care required to circumvent package shadowing, see `TraceAgentTasks.kt`).
+        if (isAsmClass(className) || isByteBuddyClass(className)) return false
+
         // We can also safely do not instrument some libraries for performance reasons.
         if (className.startsWith("com.esotericsoftware.kryo.")) return false
-        if (className.startsWith("net.bytebuddy.")) return false
         if (className.startsWith("net.rubygrapefruit.platform.")) return false
         if (className.startsWith("io.mockk.")) return false
         if (className.startsWith("it.unimi.dsi.fastutil.")) return false
         if (className.startsWith("worker.org.gradle.")) return false
-        if (className.startsWith("org.objectweb.asm.")) return false
         if (className.startsWith("org.gradle.")) return false
         if (className.startsWith("org.slf4j.")) return false
         if (className.startsWith("org.apache.commons.lang.")) return false
         if (className.startsWith("org.junit.")) return false
         if (className.startsWith("junit.framework.")) return false
-        // Finally, we should never instrument the Lincheck classes.
-        if (className.startsWith(LINCHECK_PACKAGE_NAME)) return false
-        if (className.startsWith(LINCHECK_KOTLINX_PACKAGE_NAME)) return false
-        if (className.startsWith(LINCHECK_RELOCATED_PACKAGE_PREFIX)) return false
+
         // All the classes that were not filtered out are eligible for transformation.
         return true
     }

common/src/main/org/jetbrains/lincheck/util/Logger.kt

@@ -11,10 +11,20 @@
 package org.jetbrains.lincheck.util
 
 import java.io.*
-import java.time.LocalDateTime
-import java.time.format.DateTimeFormatter
 
+/**
+ * Logging utilities for the Lincheck framework.
+ *
+ * Supports logging to `stderr` or to a specified file.
+ * If a log file is specified through the `lincheck.logFile` system property,
+ * then the file-based logging is used. Otherwise, messages are logged to the standard error stream.
+ *
+ * Logging levels can be configured using the `lincheck.logLevel` system property, see [LoggingLevel].
+ *
+ * NOTE: when stderr is used, log messages from shutdown hooks are not guaranteed to be written.
+ */
 object Logger {
+
     val logFile: File? = System.getProperty("lincheck.logFile")?.let { fileName ->
         File(fileName).also { runCatching { initFile(it) }.getOrNull() }
     }
@@ -28,60 +38,101 @@ object Logger {
         runCatching { LoggingLevel.valueOf(it) }.getOrElse { DEFAULT_LOG_LEVEL }
     } ?: DEFAULT_LOG_LEVEL
 
-    inline fun error(lazyMessage: () -> String) = log(LoggingLevel.ERROR, lazyMessage)
+    inline fun error(lazyMessage: () -> String) {
+        log(LoggingLevel.ERROR, lazyMessage)
+    }
 
-    inline fun warn(lazyMessage: () -> String) = log(LoggingLevel.WARN, lazyMessage)
+    inline fun warn(lazyMessage: () -> String) {
+        log(LoggingLevel.WARN, lazyMessage)
+    }
 
-    inline fun info(lazyMessage: () -> String) = log(LoggingLevel.INFO, lazyMessage)
+    inline fun info(lazyMessage: () -> String) {
+        log(LoggingLevel.INFO, lazyMessage)
+    }
 
-    inline fun debug(lazyMessage: () -> String) = log(LoggingLevel.DEBUG, lazyMessage)
+    inline fun debug(lazyMessage: () -> String) {
+        log(LoggingLevel.DEBUG, lazyMessage)
+    }
 
-    fun error(e: Throwable) = log(LoggingLevel.ERROR, e)
+    inline fun verbose(lazyMessage: () -> String) {
+        log(LoggingLevel.VERBOSE, lazyMessage)
+    }
 
-    fun warn(e: Throwable) = log(LoggingLevel.WARN, e)
+    inline fun error(e: Throwable, lazyMessage: () -> String = { e.message ?: "" }) {
+        log(LoggingLevel.ERROR, e, lazyMessage)
+    }
 
-    fun info(e: Throwable) = log(LoggingLevel.INFO, e)
+    inline fun warn(e: Throwable, lazyMessage: () -> String = { e.message ?: "" }) {
+        log(LoggingLevel.WARN, e, lazyMessage)
+    }
 
-    fun debug(e: Throwable) = log(LoggingLevel.DEBUG, e)
+    inline fun info(e: Throwable, lazyMessage: () -> String = { e.message ?: "" }) {
+        log(LoggingLevel.INFO, e, lazyMessage)
+    }
+
+    inline fun debug(e: Throwable, lazyMessage: () -> String = { e.message ?: "" }) {
+        log(LoggingLevel.DEBUG, e, lazyMessage)
+    }
+
+    inline fun verbose(e: Throwable, lazyMessage: () -> String = { e.message ?: "" }) {
+        log(LoggingLevel.VERBOSE, e, lazyMessage)
+    }
 
     inline fun log(logLevel: LoggingLevel, lazyMessage: () -> String) {
         if (logLevel >= this.logLevel) {
-            write(logLevel, lazyMessage(), logWriter)
+            write("[${Logger.logLevel.name}] ${lazyMessage()}$LINE_SEPARATOR")
+        }
+    }
+
+    inline fun log(logLevel: LoggingLevel, throwable: Throwable, lazyMessage: () -> String = { throwable.message ?: "" }) {
+        log(logLevel) {
+            createExceptionMessage(lazyMessage(), throwable)
         }
     }
 
-    fun write(logLevel: LoggingLevel, s: String, writer: Writer) {
+    fun write(message: String) {
         try {
-            writer.write("[${logLevel.name}] $s$LINE_SEPARATOR")
-            writer.flush()
+            logWriter.write(message)
+            logWriter.flush()
         } catch (e: IOException) {
             e.printStackTrace()
         }
     }
 
-    private fun log(logLevel: LoggingLevel, throwable: Throwable) {
-        log(logLevel) {
-            StringWriter().use { writer ->
-                throwable.printStackTrace(PrintWriter(writer))
-                writer.toString()
+    fun createExceptionMessage(message: String, throwable: Throwable): String {
+        val writer = StringWriter().apply {
+            PrintWriter(this).use { printer ->
+                throwable.printStackTrace(printer)
             }
         }
+        val stackTrace = writer.toString()
+        if (message.isNotEmpty()) {
+            val paddedStackTrace = stackTrace.lines().joinToString(separator = LINE_SEPARATOR) { TAB + it }
+            return "${message}${LINE_SEPARATOR}${paddedStackTrace}"
+        } else {
+            return stackTrace
+        }
     }
 
     private fun initFile(file: File) {
         // create parent directories
-        file.parentFile?.let { if (!it.exists()) it.mkdirs() }
+        file.parentFile?.let { parent ->
+            if (!parent.exists()) parent.mkdirs()
+        }
 
-        // create file
-        if (file.exists()) file.delete()
+        // create the file
+        if (file.exists()) {
+            file.delete()
+        }
         file.createNewFile()
     }
-}
 
-private val LINE_SEPARATOR = System.lineSeparator()
+    val TAB: String = "\t"
+    val LINE_SEPARATOR: String = System.lineSeparator()
+}
 
 @JvmField val DEFAULT_LOG_LEVEL = LoggingLevel.WARN
 
 enum class LoggingLevel {
-    DEBUG, INFO, WARN, ERROR, OFF
+    VERBOSE, DEBUG, INFO, WARN, ERROR, OFF
 }