nieuwste benchmar

Author: MPCoreDeveloper

README.md

@@ -0,0 +1,271 @@
+# ?? Quick 10K Benchmark - Resultaten Beoordeling
+
+## ? HUIDIGE STATUS: BENCHMARKS FALEN NOG STEEDS
+
+### ?? Waargenomen Problemen
+
+**Symptomen**:
+```
+| Method                                             | Mean | Error | Ratio |
+|--------------------------------------------------- |-----:|------:|------:|
+| 'SharpCoreDB (No Encryption): 10K Batch Insert'    |   NA |    NA |     ? |
+| 'SQLite (Memory): 10K Batch Insert'                |   NA |    NA |     ? |
+| 'LiteDB: 10K Bulk Insert'                          |   NA |    NA |     ? |
+
+Benchmarks with issues:
+  Quick10kComparison.'SharpCoreDB (No Encryption): 10K Batch Insert'
+  Quick10kComparison.'SQLite (Memory): 10K Batch Insert'  
+  Quick10kComparison.'LiteDB: 10K Bulk Insert'
+```
+
+**Metingen gevonden**:
+- ? Jitting fase: WEL metingen (8.3 sec voor SharpCoreDB, 142ms voor SQLite, 476ms voor LiteDB)
+- ? Workload iterations: GEEN metingen (crashes na jitting)
+
+---
+
+## ?? TOEGEPASTE FIXES
+
+### Fix #1: IterationSetup Added (GEÏMPLEMENTEERD)
+```csharp
+[IterationSetup]
+public void IterationSetup()
+{
+    // Clear SQLite tables
+    sqliteMemory: DELETE FROM users
+    sqliteFile: DELETE FROM users
+    
+    // Clear LiteDB
+    liteCollection.DeleteAll()
+}
+```
+
+**Resultaat**: HELPT NIET - nog steeds NA
+
+---
+
+### Fix #2: Thread-Safe ID Generation (GEÏMPLEMENTEERD)
+```csharp
+private static int globalCounter = 0;
+
+public void SharpCoreDB_NoEncrypt_10K()
+{
+    var baseId = Interlocked.Increment(ref globalCounter) * 1000000;
+    // Use IDs: 1000000-1009999, 2000000-2009999, etc.
+}
+```
+
+**Resultaat**: NOG TE TESTEN
+
+---
+
+## ?? WAARSCHIJNLIJKE OORZAKEN
+
+### Hypothese #1: Benchm arkDotNet Process Isolation
+BenchmarkDotNet start benchmarks in **separate processes**. Dit kan problemen veroorzaken met:
+- Database connections
+- File locks
+- Temp directory cleanup
+- Shared state
+
+**Bewijs**:
+```
+Environment
+  Summary -> Detected error exit code from one of the benchmarks.
+  It might be caused by following antivirus software:
+        - Windows Defender (windowsdefender://)
+  Use InProcessEmitToolchain or InProcessNoEmitToolchain to avoid new process creation.
+```
+
+---
+
+### Hypothese #2: Database Initialization Failure
+De `GlobalSetup` faalt mogelijk in het child process.
+
+**Mogelijke oorzaken**:
+- ? SharpCoreDB DI container niet beschikbaar in child process
+- ? Encryption keys niet beschikbaar
+- ? File permissions issues
+- ? Temp directory niet beschikbaar
+
+---
+
+### Hypothese #3: Exception in Benchmark Method
+De benchmark methods zelf crashen tijdens executie.
+
+**Mogelijke oorzaken**:
+- ? `InsertUsersTrueBatch` faalt op SQL syntax errors
+- ? Connection disposed tussen jitting en workload
+- ? Transaction rollback op error
+
+---
+
+## ?? AANBEVOLEN OPLOSSINGEN
+
+### Oplossing A: Use InProcess Toolchain (EENVOUDIGST)
+```csharp
+[Config(typeof(InProcessConfig))]
+public class Quick10kComparison
+```
+
+**Voordelen**:
+- ? Geen process isolation issues
+- ? Debugging mogelijk
+- ? Shared state werkt
+
+**Nadelen**:
+- ?? Minder accurate metingen (geen process cleanup tussen runs)
+- ?? Mogelijk geheugen leaks tussen iterations
+
+---
+
+### Oplossing B: Simpele Console App (DEBUGGING)
+Maak een eenvoudige console app die EXACT dezelfde code runt als de benchmark:
+
+```csharp
+// Program.cs
+var benchmark = new Quick10kComparison();
+benchmark.Setup();
+
+try
+{
+    benchmark.IterationSetup();
+    benchmark.SharpCoreDB_NoEncrypt_10K();
+    Console.WriteLine("? SUCCESS!");
+}
+catch (Exception ex)
+{
+    Console.WriteLine($"? ERROR: {ex.Message}");
+    Console.WriteLine(ex.StackTrace);
+}
+finally
+{
+    benchmark.Cleanup();
+}
+```
+
+**Doel**: Ontdek de EXACTE exception die wordt gegooid
+
+---
+
+### Oplossing C: Logging Toevoegen
+```csharp
+[Benchmark]
+public void SharpCoreDB_NoEncrypt_10K()
+{
+    Console.WriteLine("[START] SharpCoreDB_NoEncrypt_10K");
+    
+    try
+    {
+        var users = dataGenerator.GenerateUsers(RecordCount);
+        Console.WriteLine($"[OK] Generated {users.Count} users");
+        
+        var baseId = Interlocked.Increment(ref globalCounter) * 1000000;
+        Console.WriteLine($"[OK] BaseID = {baseId}");
+        
+        var userList = users.Select((u, i) => (baseId + i, u.Name, u.Email, u.Age, u.CreatedAt, u.IsActive)).ToList();
+        Console.WriteLine($"[OK] Prepared {userList.Count} records");
+        
+        sharpCoreDbNoEncrypt?.InsertUsersTrueBatch(userList);
+        Console.WriteLine("[END] Insert complete");
+    }
+    catch (Exception ex)
+    {
+        Console.WriteLine($"[ERROR] {ex.Message}");
+        throw;
+    }
+}
+```
+
+---
+
+## ?? VOLGENDE STAPPEN
+
+### Stap 1: InProcess Config Proberen (HOOGSTE PRIORITEIT)
+```csharp
+[SimpleJob(BenchmarkDotNet.Engines.RunStrategy.Throughput, invocationCount: 1)]
+[InProcess]
+public class Quick10kComparison
+```
+
+### Stap 2: Debug Console App Maken
+Maak `QuickDebugTest.cs` die de benchmark code runt zonder BenchmarkDotNet.
+
+### Stap 3: Logging Toevoegen
+Voeg Console.WriteLine toe om te zien waar het crasht.
+
+### Stap 4: Check Logs
+Kijk in `BenchmarkDotNet.Artifacts/logs/` voor detailed error messages.
+
+---
+
+## ?? VERWACHTE RESULTATEN (als het werkt)
+
+Gebaseerd op de Jitting metingen:
+
+| Database | Jitting Time | Geschatte Final Time |
+|----------|--------------|----------------------|
+| SQLite (Memory) | 142ms | **~50-100ms** ?? |
+| SQLite (File+WAL) | 147ms | **~50-100ms** ?? |
+| LiteDB | 476ms | **~400-600ms** ?? |
+| SharpCoreDB (No Enc) | 8,300ms | **~7-10 sec** ?? |
+| SharpCoreDB (Encrypted) | 8,549ms | **~40-50 sec** ? |
+
+**Conclusie**: SQLite domineert bulk inserts (zoals verwacht).
+
+---
+
+## ? WAT WEL WERKT
+
+### Andere Benchmarks Zijn Succesvol
+Kijkend naar de artifacts folder zien we:
+- ? `ComparativeInsertBenchmarks` - HAS RESULTS
+- ? `ComparativeSelectBenchmarks` - HAS RESULTS
+- ? `ComparativeUpdateDeleteBenchmarks` - HAS RESULTS
+- ? `GroupCommitWALBenchmarks` - HAS RESULTS
+
+**Dit betekent**:
+- ? BenchmarkDotNet werkt in principe
+- ? SharpCoreDB werkt in principe
+- ? Er is iets specifiek mis met `Quick10kComparison`
+
+---
+
+## ?? DEBUGGING PLAN
+
+1. **Vergelijk met werkende benchmarks**
+   - Kijk naar `ComparativeInsertBenchmarks.cs`
+   - Zie wat zij anders doen
+
+2. **Simplify Quick10kComparison**
+   - Verwijder IterationSetup
+   - Gebruik gewoon random IDs
+   - Test met 100 records eerst
+
+3. **Check de logs**
+   ```
+   SharpCoreDB.Benchmarks\BenchmarkDotNet.Artifacts\logs\
+   ```
+
+---
+
+## ?? CONCLUSIE
+
+**Status**: ? NIET WERKEND
+
+**Hoofdprobleem**: Benchmarks crashen na jitting, voor workload iterations
+
+**Waarschijnlijke oorzaak**: BenchmarkDotNet process isolation issues
+
+**Aanbevolen fix**: 
+1. Probeer InProcess toolchain
+2. Maak debug console app
+3. Vergelijk met werkende benchmarks
+
+**ETA voor fix**: 30-60 minuten werk
+
+---
+
+**Laatste update**: December 2025  
+**Status**: ?? Needs Investigation  
+**Priority**: HIGH