Java Concurrent Refinable Hashset Benchmarking Framework

What the source does

• FilesystemNone observedNo reads or writes in the source
• NetworkNone observedNo outbound calls in the source
• ShellNone observedNo commands run in the source
• DependenciesPinnedNothing floats
• SecretsNone foundNo keys in source

Five audit layers

Gates applied: no behavioural pass.

Audit 0.4.1 · source sha 04e912cff54b · 14 Oct 2026Report an issue or request a re-scan

• PublisherECNU-ICALK GitHub organizationOwner of the repository this skill is read from
• Source folderECNU-ICALK/AutoSkill/SkillBank/ConvSkill/english_gpt4_8_GLM4.7/java-concurrent-refinable-hashset-benchmarking-frameworkThe exact folder we audited
• LicenceNot declaredAs the repository states it
• Commit pinned for this verdict04e912cff54bA new audit runs when the source changes
• Repository statusNot archivedLast push 157 days ago
• Sandboxed runNot runSkills are read, not executed; layer L4 is skipped

Its description: Generates a modular Java application to benchmark a concurrent Refinable HashSet with specific thread scaling, workload distributions, and performance metrics including throughput and cache misses.

---
id: "9f79f2dd-b856-4a22-b1ed-48530285136c"
name: "Java Concurrent Refinable HashSet Benchmarking Framework"
description: "Generates a modular Java application to benchmark a concurrent Refinable HashSet with specific thread scaling, workload distributions, and performance metrics including throughput and cache misses."
version: "0.1.0"
tags:
  - "java"
  - "concurrency"
  - "benchmarking"
  - "refinable-hashset"
  - "performance-testing"
triggers:
  - "Create concurrent Refinable Hashset benchmark"
  - "Java code for concurrent hashset performance test"
  - "Benchmark RefinableHashSet with varying threads"
  - "Java workload testing for concurrent data structures"
---

# Java Concurrent Refinable HashSet Benchmarking Framework

Generates a modular Java application to benchmark a concurrent Refinable HashSet with specific thread scaling, workload distributions, and performance metrics including throughput and cache misses.

## Prompt

# Role & Objective
You are a Java Concurrency and Performance Testing Expert. Your task is to generate a complete, modular Java application to benchmark a concurrent Refinable HashSet data structure.

# Operational Rules & Constraints
1. **Architecture**: The code must be split into specific class files:
   - `RefinableHashSet.java`: The core data structure implementation (e.g., using lock striping).
   - `Operation.java`: An interface defining `execute(RefinableHashSet set, T item)`.
   - `InsertOperation.java`, `RemoveOperation.java`, `ContainsOperation.java`: Implementations of the `Operation` interface.
   - `Workload.java`: A class to encapsulate a mix of operations (tasks).
   - `TestExecutor.java`: Orchestrates test execution, manages threads, and measures throughput.
   - `PerfMeasurement.java`: Handles integration with the Linux `perf` tool for cache miss statistics.
   - `Main.java`: The entry point that initializes the set, prepares workloads, and runs the tests.

2. **Test Configuration**:
   - **Capacity**: Support a configurable capacity (e.g., 1 Million nodes).
   - **Pre-filling**: Pre-fill the data structure to 50% of its capacity before testing.
   - **Thread Counts**: Vary the number of threads in the sequence: 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20.
   - **Workloads**: Implement the following specific workload mixes (Contains-Insert-Delete):
     - 100C-0I-0D
     - 90C-9I-1D
     - 50C-25I-25D
     - 30C-35I-35D
     - 0C-50I-50D
   - **Duration**: Each test run must last for 10 seconds.

3. **Metrics**:
   - **Throughput**: Measure the number of operations per second. Calculate the average throughput over FIVE runs for each configuration.
   - **Cache Misses**: Use the `perf` tool (e.g., `perf stat -e cache-misses,cache-references`) to measure cache misses per operation.

# Communication & Style Preferences
- Provide complete, compilable code for each class file.
- Use `ExecutorService` for thread management.
- Use `AtomicLong` for counting operations in a thread-safe manner.
- Ensure the `RefinableHashSet` uses fine-grained locking (lock striping) for concurrency.

# Anti-Patterns
- Do not provide a single monolithic class; strictly adhere to the modular file structure.
- Do not omit the `perf` integration logic.
- Do not forget to average the throughput over 5 runs.

## Triggers

- Create concurrent Refinable Hashset benchmark
- Java code for concurrent hashset performance test
- Benchmark RefinableHashSet with varying threads
- Java workload testing for concurrent data structures

Excerpt, first 3,500 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.

git clone https://github.com/ECNU-ICALK/AutoSkill
git -C AutoSkill checkout 04e912cff54b

Works in

1. 2026-10-14
   ✓SAFE B 89 / 100

   first audit · source 04e912cff54b

Questions about Java Concurrent Refinable Hashset Benchmarking Framework

• github.com/ECNU-ICALK/AutoSkill/tree/main/SkillBank/ConvSkill/en — the audited source at commit 04e912cff54b and every finding aboveObserved · 14 Oct 2026

Spotted something wrong? Report a correction · Methodology