Add @IgnoreNonStaticTraceComponent annotation for instance-specific tracing

- Created new annotation to mark legitimate non-static TraceComponent fields
- Updated instrumentation tool to skip annotated fields
- Migrated 3 files from Object-cast workaround to direct field access
- Eliminates method call and cast overhead on every trace operation
- Improves code clarity and maintainability

Author: jimblye

DirectoryComparer/DirectoryComparer.jar

@@ -0,0 +1,29 @@
+JAVAC = javac
+JAVA = java
+JAR = jar
+SRC_DIR = src
+BIN_DIR = bin
+MAIN_CLASS = com.dircompare.DirectoryComparer
+CLASSPATH = $(BIN_DIR)
+JAR_FILE = DirectoryComparer.jar
+
+all: compile
+
+compile:
+	@mkdir -p $(BIN_DIR)
+	$(JAVAC) -d $(BIN_DIR) $(SRC_DIR)/com/dircompare/DirectoryComparer.java
+
+jar: compile
+	$(JAR) cfm $(JAR_FILE) manifest.txt -C $(BIN_DIR) .
+
+run:
+	$(JAVA) -cp $(CLASSPATH) $(MAIN_CLASS) $(DIR1) $(DIR2)
+
+run-jar:
+	$(JAVA) -jar $(JAR_FILE) $(DIR1) $(DIR2)
+
+clean:
+	rm -rf $(BIN_DIR)
+	rm -f $(JAR_FILE)
+
+.PHONY: all compile jar run run-jar clean

DirectoryComparer/Makefile

@@ -0,0 +1,95 @@
+# Directory Comparer
+
+A Java utility to compare Java files between two directories.
+
+## Features
+
+- Identifies Java files that are in the first directory but not in the second
+- Identifies Java files that are in the second directory but not in the first
+- Identifies Java files that exist in both directories but have different content
+- Ignores all non-Java files
+
+## Requirements
+
+- Java JDK 8 or higher
+- Make (optional, for using the Makefile)
+
+## Building the Project
+
+Using Make:
+
+```bash
+cd DirectoryComparer
+make compile
+```
+
+Manually:
+
+```bash
+cd DirectoryComparer
+mkdir -p bin
+javac -d bin src/com/dircompare/DirectoryComparer.java
+```
+
+## Running the Program
+
+Using Make:
+
+```bash
+make run DIR1=/path/to/first/directory DIR2=/path/to/second/directory
+```
+
+Manually:
+
+```bash
+java -cp bin com.dircompare.DirectoryComparer /path/to/first/directory /path/to/second/directory
+```
+
+## Creating and Running a JAR File
+
+To create an executable JAR file:
+
+```bash
+cd DirectoryComparer
+make jar
+```
+
+This will create `DirectoryComparer.jar` in the project directory.
+
+To run the JAR file:
+
+```bash
+java -jar DirectoryComparer.jar /path/to/first/directory /path/to/second/directory
+```
+
+Or using Make:
+
+```bash
+make run-jar DIR1=/path/to/first/directory DIR2=/path/to/second/directory
+```
+
+## Example Output
+
+```
+Directory Comparison Results:
+============================
+
+Files only in /path/to/first/directory:
+  SomeFile.java
+  subdir/AnotherFile.java
+
+Files only in /path/to/second/directory:
+  NewFile.java
+
+Files with different content:
+  CommonFile.java
+  utils/Helper.java
+```
+
+## How It Works
+
+The program recursively scans both directories, filtering for Java files only. It then:
+
+1. Compares file paths to identify files unique to each directory
+2. For files that exist in both directories, compares their content byte-by-byte
+3. Outputs the results in a clear, categorized format

DirectoryComparer/README.md

@@ -0,0 +1 @@
+Main-Class: com.dircompare.DirectoryComparer

DirectoryComparer/manifest.txt

@@ -0,0 +1,170 @@
+package com.dircompare;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * A utility to compare Java files between two directories.
+ * Identifies files that are:
+ * 1. In the first directory but not in the second
+ * 2. In the second directory but not in the first
+ * 3. In both directories but with different contents
+ */
+public class DirectoryComparer {
+
+    public static void main(String[] args) {
+        if (args.length != 2) {
+            System.out.println("Usage: java DirectoryComparer <directory1> <directory2>");
+            System.exit(1);
+        }
+
+        String dir1Path = args[0];
+        String dir2Path = args[1];
+
+        DirectoryComparer comparer = new DirectoryComparer();
+        try {
+            comparer.compareDirectories(dir1Path, dir2Path);
+        } catch (IOException e) {
+            System.err.println("Error comparing directories: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Compares two directories and prints the differences.
+     * 
+     * @param dir1Path Path to the first directory
+     * @param dir2Path Path to the second directory
+     * @throws IOException If an I/O error occurs
+     */
+    public void compareDirectories(String dir1Path, String dir2Path) throws IOException {
+        Path path1 = Paths.get(dir1Path);
+        Path path2 = Paths.get(dir2Path);
+
+        // Validate directories
+        if (!Files.isDirectory(path1)) {
+            throw new IllegalArgumentException(dir1Path + " is not a directory");
+        }
+        if (!Files.isDirectory(path2)) {
+            throw new IllegalArgumentException(dir2Path + " is not a directory");
+        }
+
+        // Get all Java files from both directories
+        Map<String, Path> javaFilesDir1 = findJavaFiles(path1);
+        Map<String, Path> javaFilesDir2 = findJavaFiles(path2);
+
+        // Find files in dir1 but not in dir2
+        List<String> onlyInDir1 = new ArrayList<>();
+        for (String relativePath : javaFilesDir1.keySet()) {
+            if (!javaFilesDir2.containsKey(relativePath)) {
+                onlyInDir1.add(relativePath);
+            }
+        }
+
+        // Find files in dir2 but not in dir1
+        List<String> onlyInDir2 = new ArrayList<>();
+        for (String relativePath : javaFilesDir2.keySet()) {
+            if (!javaFilesDir1.containsKey(relativePath)) {
+                onlyInDir2.add(relativePath);
+            }
+        }
+
+        // Find files in both directories but with different content
+        List<String> differentContent = new ArrayList<>();
+        for (String relativePath : javaFilesDir1.keySet()) {
+            if (javaFilesDir2.containsKey(relativePath)) {
+                Path file1 = javaFilesDir1.get(relativePath);
+                Path file2 = javaFilesDir2.get(relativePath);
+                
+                if (!filesHaveSameContent(file1, file2)) {
+                    differentContent.add(relativePath);
+                }
+            }
+        }
+
+        // Print results
+        System.out.println("Directory Comparison Results:");
+        System.out.println("============================");
+        
+        System.out.println("\nFiles only in " + dir1Path + ":");
+        if (onlyInDir1.isEmpty()) {
+            System.out.println("None");
+        } else {
+            onlyInDir1.forEach(file -> System.out.println("  " + file));
+        }
+
+        System.out.println("\nFiles only in " + dir2Path + ":");
+        if (onlyInDir2.isEmpty()) {
+            System.out.println("None");
+        } else {
+            onlyInDir2.forEach(file -> System.out.println("  " + file));
+        }
+
+        System.out.println("\nFiles with different content:");
+        if (differentContent.isEmpty()) {
+            System.out.println("None");
+        } else {
+            differentContent.forEach(file -> System.out.println("  " + file));
+        }
+    }
+
+    /**
+     * Finds all Java files in the given directory and its subdirectories.
+     * 
+     * @param directory The directory to search
+     * @return A map of relative paths to absolute paths for all Java files
+     * @throws IOException If an I/O error occurs
+     */
+    private Map<String, Path> findJavaFiles(Path directory) throws IOException {
+        Map<String, Path> javaFiles = new HashMap<>();
+        
+        try (Stream<Path> walk = Files.walk(directory)) {
+            List<Path> files = walk
+                .filter(Files::isRegularFile)
+                .filter(path -> path.toString().toLowerCase().endsWith(".java"))
+                .collect(Collectors.toList());
+            
+            for (Path file : files) {
+                String relativePath = directory.relativize(file).toString();
+                javaFiles.put(relativePath, file);
+            }
+        }
+        
+        return javaFiles;
+    }
+
+    /**
+     * Compares the content of two files.
+     * 
+     * @param file1 Path to the first file
+     * @param file2 Path to the second file
+     * @return true if the files have the same content, false otherwise
+     * @throws IOException If an I/O error occurs
+     */
+    private boolean filesHaveSameContent(Path file1, Path file2) throws IOException {
+        byte[] content1 = Files.readAllBytes(file1);
+        byte[] content2 = Files.readAllBytes(file2);
+        
+        if (content1.length != content2.length) {
+            return false;
+        }
+        
+        for (int i = 0; i < content1.length; i++) {
+            if (content1[i] != content2[i]) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+}
+
+// Made with Bob