test: add focused performance baseline

This commit is contained in:
Algent committed 2026-08-27 20:51:57 +03:00
1 parent 2aa9928ad0
commit 54d6df002e
8 files changed
+370 -22

No files matched your search

+22 -11
View File
@@ -23,9 +23,9 @@ No trustworthy tool will produce a maintainable Java port automatically. A decom
## Current status
The binary and source-level consumer audits are complete. Phase 0 still lacks a pre-optimization profile. The
low-coupling Phase 3 queue and the audit-derived immediate compatibility gate are complete. The next milestone is a
focused CPU/allocation baseline before entering measured hot-path work.
The binary and source-level consumer audits, low-coupling Phase 3 queue, audit-derived immediate compatibility gate,
and focused pre-optimization profile are complete. Phase 4 can now begin with the measured `TileMultipart` traversal
path; see `JAVA_MIGRATION_PROFILE.md`.
That audit found and this branch has now repaired one existing regression: Schematica 1.12.6 reflects the original private
`MultiPartRegistry$` field `codechicken$multipart$MultiPartRegistry$$typeMap` and casts it to a Scala mutable map. The
@@ -123,13 +123,18 @@ Exception-table metadata does not impose a meaningful steady-state cost merely b
The source and bytecode audit identified allocation patterns that are more plausible performance targets:
- `TileMultipart.updateEntity()` creates a Scala closure for each ticking multipart tile on each tick, then traverses through `operate(Function1)` and Scala collection machinery.
- `TRedstoneTile` power and connection queries create closures and `scala.runtime.IntRef` boxes in frequently queried code.
- The Java port's `TileMultipart.updateEntity()` still traverses through `operate(Function1)`, whose current
`parts()` helper materializes an `ArrayList`, backing array, Scala iterator and Java-conversion wrappers per call.
- `TRedstoneTile` power and connection queries create closures and `scala.runtime.IntRef` boxes in frequently queried
code.
- Several Scala 2.11 collection, range, and `JavaConversions` paths create closure objects, boxed primitives, iterators, or temporary collections.
- `TSlottedTile.canAddPart` and several `MicroRecipe` searches use exception-based non-local returns.
- Rendering code in `TileMultipart` already uses cached arrays and `while` loops in important paths. It should be preserved as evidence of deliberate optimization, not mechanically rewritten into streams or higher-level collection pipelines.
These are static findings, not proof of their share of frame or tick time. Capture profiles and allocation data before and after each relevant migration phase.
The focused Forge/JFR baseline confirms both risks. With eight parts, `updateEntity` and `operate` allocate about 184
bytes per call, while a three-query redstone iteration allocates 80.5 bytes. CPU samples identify the same collection,
boxing and closure paths. These are focused measurements, not whole-pack TPS; retain the workload and re-profile after
each relevant migration phase. See `JAVA_MIGRATION_PROFILE.md`.
### Runtime code generation is architectural, not incidental
@@ -249,7 +254,8 @@ If a characterization test captures a confirmed bug that the port intentionally
- [x] Add a separate Forge integration-test source set/runner for behavior that cannot execute in a plain JVM.
- [x] Write the first characterization suite against the untouched Scala implementation.
- [x] Create a remaining manual compatibility checklist for rendering, input, and other behavior that cannot be asserted reliably by the automated harness. See `JAVA_MIGRATION_MANUAL_CHECKS.md`.
- [ ] Capture representative CPU and allocation profiles before optimization work.
- [x] Capture representative CPU and allocation profiles before optimization work. See
`JAVA_MIGRATION_PROFILE.md`.
- [x] Start a divergence log.
Exit condition: there is a reproducible behavior and ABI baseline, the test layers run in CI or an equivalent repeatable command, and the initial suite passes against the Scala implementation.
@@ -323,10 +329,11 @@ and the already-ported registry again supports Schematica.
- [ ] Use fastutil only where profiling and data shape justify it.
- [ ] Re-profile the same scenarios and record both improvements and regressions.
Status: not started. This phase does not begin until the immediate compatibility gate and an initial profile are
complete. The first sensible implementation unit is the whole `IRedstonePart.scala` file: its six related traits and
load-bearing `RedstoneInteractions$` must be characterized and ported together. Do not optimize `TileMultipart`
storage merely because the source audit found allocations; its list/order/lifecycle contracts must be frozen first.
Status: ready to start. The compatibility gate and initial profile are complete. First freeze `operate` behavior when
callbacks add or remove parts, then remove the measured per-traversal `ArrayList`/array/wrapper materialization while
retaining the public Scala `Seq` and `operate(Function1)` ABI. Re-run the focused profile immediately. The next broader
unit is the whole `IRedstonePart.scala` file: its six related traits and load-bearing `RedstoneInteractions$` must be
characterized and ported together.
Exit condition: identified steady-state Scala allocation sites are removed with compatible results.
@@ -631,4 +638,8 @@ generated-trait compatibility work. Scala-runtime removal remains a later projec
- Froze a server-only pass-through interface with primitive/reference overloads. The generated tile forwards to one
implementing part, rejects a second implementor, preserves and rebinds its delegate through `copyFrom`, and clears
the generated implementation field on removal.
- Added an opt-in Forge/JFR workload and captured the first focused CPU/allocation baseline. With eight parts,
`updateEntity` and `operate` allocate 184.0 and 183.9 bytes per call; generated redstone's three-query iteration
allocates 80.5 bytes. CPU and allocation sites point to `TileMultipart.parts()` collection copies and Scala
redstone `IntRef`/closure traversal. Full methodology and rerun commands are in `JAVA_MIGRATION_PROFILE.md`.
- The expanded baseline is 130 plain-JVM tests and 28 Forge server tests, all passing.
+4 -2
View File
@@ -662,8 +662,10 @@ same messages, since Scala's `assert` is always enabled here and Java's is not.
`partList` remains a `scala.collection.immutable.List` published through `partList()Lscala/collection/Seq;`, which
five jars link against. Mutations copy to a Java list, mutate, and republish through `JavaConversions`, matching the
reference's allocate-a-new-Seq semantics exactly. No performance decision is taken here; that is Phase 4 work and
needs profiling first.
reference's allocate-a-new-Seq semantics exactly. The focused Phase 4 baseline later found that the Java port's
`parts()` read helper also materializes an `ArrayList`, backing array, iterator and conversion wrappers on every
traversal. That read-side cost is not required by the reference and is the next measured optimization target; see
`JAVA_MIGRATION_PROFILE.md`.
`operate` keeps its `(Lscala/Function1;)V` descriptor and internal callers still go through it, wrapping their action
in an `AbstractFunction1`. That preserves both the virtual dispatch, so any trait overriding `operate` still sees
+23 -8
View File
@@ -10,8 +10,9 @@ what breaks, and what is left. The other documents hold the reasoning.
| `JAVA_MIGRATION_CONSUMER_AUDIT.md` | How every consumer uses FMP at runtime: data, lifecycle, reflection, and generated tiles |
| `JAVA_MIGRATION_DIVERGENCES.md` | Every intentional difference from the reference, one entry per port |
| `JAVA_MIGRATION_MANUAL_CHECKS.md` | What no automated test can cover, and must be checked by hand in a client |
| `JAVA_MIGRATION_PROFILE.md` | The focused pre-optimization baseline, findings, and exact rerun command |
Branch: `algent/java`. Base: `master`. 54 commits so far.
Branch: `algent/java`. Base: `master`. 62 commits including the profile-baseline commit.
## The one rule that matters
@@ -47,6 +48,14 @@ test, and if you do adjust it, re-run it against the stashed Scala to prove the
./gradlew runFunctionalTestServer
```
Focused CPU/allocation profile from PowerShell:
```powershell
.\gradlew.bat runFunctionalTestServer "-Pforgemultipart.profileFunctionalTests=true"
```
See `JAVA_MIGRATION_PROFILE.md` before comparing its ignored `.jfr` and text outputs.
Test result counts (the Gradle output does not print them):
```bash
@@ -211,9 +220,14 @@ The immediate compatibility gate is complete. `ForgeEnvironmentSmokeTest` now fr
trait generation, Java-trait rewriting/dispatch, generated-class reuse, and a server-only pass-through interface's
overloads, single-implementor rule, copy/rebind behavior, and removal cleanup.
Next capture a focused CPU/allocation baseline for `TileMultipart.updateEntity`, `TileMultipart.operate`, and redstone
queries. Use the measurements to select the first Phase 4 change rather than assuming the statically visible
allocations dominate.
The focused CPU/allocation baseline is complete. It measures about 184 allocated bytes per eight-part
`updateEntity`/`operate` call and 80.5 bytes per generated redstone three-query iteration. JFR attributes the first pair
to `TileMultipart.parts()` collection conversion/copying and the redstone path to Scala iteration, `IntRef`, and
generated closures. Full results and rerun commands are in `JAVA_MIGRATION_PROFILE.md`.
Next freeze `operate` behavior when callbacks add or remove parts, then remove its measured per-call collection
materialization without changing the Scala `Seq`/`Function1` ABI. Re-run the same profile before starting the complete
`IRedstonePart.scala` unit.
`IRedstonePart.scala` is misleadingly named and is **not** a marker-trait file. It holds six traits plus
`RedstoneInteractions`, whose `MODULE$` is load-bearing. After the compatibility gate and an initial profile, port the
@@ -235,13 +249,14 @@ all of `multipart/asm/`. The ASM subsystem should be last; freeze generated-clas
- The full manual checklist has not been completed. Limited smoke testing has been performed in the GTNH full pack, but individual checklist items remain unrecorded and unverified.
Every port since `TCuboidPart` has deferred something to it, and `BlockMultipart` leans on it hardest: breaking, selection boxes, collision, pick block, activation, particles and
light are covered by nothing automated. Run it in a real client before this branch goes near a release.
- No CPU or allocation profiles exist. Phase 4 has not started, so there is no baseline to compare against.
- The focused synthetic baseline exists, but a representative full-GTNH-pack CPU/allocation capture is still manual
work and is required before release claims about real TPS.
- The server side of flag-sensitive pass-through registration is automated; client-side exclusion still belongs to
the packaged-client/manual compatibility run.
- Microblock-specific NBT and packet payloads still need characterization immediately before that subsystem changes;
the compact core tile/part fixture is complete.
- `TileMultipart`'s `partList` still republishes an immutable Scala `Seq` on every mutation, and `operate` still
allocates a `Function1` per call. Both are faithful to the reference and both are deliberately left for Phase 4,
which needs profiling first.
- `TileMultipart`'s `partList` still republishes an immutable Scala `Seq` on every mutation. The Java port's `parts()`
additionally materializes an `ArrayList` and backing array per traversal; the profile confirms it as the first Phase
4 target. Preserve the reference's captured-immutable-sequence mutation behavior while removing that port artifact.
- Phase 1 never properly started. GTNHLib is currently commented out in `dependencies.gradle`; it had been added at
`api` scope to satisfy a test compile rather than because a migration change needed it.
+2 -1
View File
@@ -46,5 +46,6 @@ release that includes those ports.
## Not yet covered anywhere
- CPU and allocation profiles before and after the hot-path work. Phase 4 has not started, so no baseline exists.
- A focused pre-optimization CPU/allocation baseline now exists in `JAVA_MIGRATION_PROFILE.md`. A representative
full-pack capture and the matching post-optimization comparison still need to be performed.
- NBT and packet layout fixtures beyond the material id carrier. Phase 0 still lists this as open.
+82
View File
@@ -0,0 +1,82 @@
# Java migration — focused performance baseline
This is the reproducible pre-optimization baseline for Phase 4. It runs inside the real deobfuscated Forge dedicated
server, using the same generated tiles as the functional suite. It is intentionally focused rather than a claim about
whole-pack TPS.
## Re-run
The local server EULA must already contain `eula=true`. From PowerShell at the repository root:
```powershell
.\gradlew.bat runFunctionalTestServer "-Pforgemultipart.profileFunctionalTests=true"
```
The property is quoted because PowerShell otherwise splits the dotted Gradle property. Normal
`runFunctionalTestServer` runs remain unchanged. Profile mode overwrites these ignored files:
- `run/server/forgemultipart-profile.txt` — exact timings and per-thread allocation counts;
- `run/server/forgemultipart-baseline.jfr` — JFR CPU, allocation-site, and GC events.
Useful JDK commands after the run:
```powershell
Get-Content run/server/forgemultipart-profile.txt
jfr summary run/server/forgemultipart-baseline.jfr
jfr view --width 220 hot-methods run/server/forgemultipart-baseline.jfr
jfr view thread-allocation run/server/forgemultipart-baseline.jfr
```
Open the `.jfr` in Java Mission Control for flame graphs and allocation-site inspection. The `startEpochMillis` and
`nanos` values in the text file define the exact time window for each phase. Java 8 recordings expose TLAB allocation
events rather than the newer `ObjectAllocationSample`, so `jfr view allocation-by-site` from a recent JDK is not a
valid summary of this recording.
## Workload
The fixture uses Zulu OpenJDK 8, eight parts per tile, 1,000,000 warm-up iterations, then 50,000,000 measured
iterations per phase:
- `updateEntity`: one `TileMultipart.updateEntity()` call, dispatching `update()` to eight ticking parts;
- `operate`: one `TileMultipart.operate(Function1)` call with one reused function and eight bound parts;
- `redstoneQueries`: one `strongPowerLevel`, one `getConnectionMask`, and one masked `weakPowerLevel` call on a
generated `TRedstoneTile` containing eight `IRedstonePart` implementations.
The checksum consumes all observable work. Allocation bytes come from HotSpot's per-thread allocation counter, not
from sampled JFR events. JFR remains the source for CPU samples and allocation-site ranking.
## Baseline captured 2026-08-27
Environment: Zulu 8.96 / OpenJDK `1.8.0_504-b01`, Windows 11, 16 hardware threads, `-Xms1G -Xmx4G`, JFR `profile`
settings.
| Phase | Elapsed | Operations/s | Allocated bytes | Bytes/operation | CPU samples |
| --- | ---: | ---: | ---: | ---: | ---: |
| `updateEntity` | 2.970 s | 16,835,622 | 9,198,500,864 | 184.0 | 209 |
| `operate` | 3.004 s | 16,646,549 | 9,195,084,824 | 183.9 | 205 |
| `redstoneQueries` | 3.689 s | 13,553,242 | 4,023,003,032 | 80.5 | 239 |
Timing is machine- and JIT-sensitive; compare it only with the same workload and environment. Allocation per operation
is the more stable regression metric.
### CPU and allocation-site findings
- `updateEntity` and `operate` are dominated by `TileMultipart.parts()`, `AbstractCollection.toArray`, Scala list
length/iteration, and Java-conversion wrappers. Their nearly identical 184-byte allocation cost shows that the
traversal snapshot, not the update callback itself, is the first target.
- The current Java `parts()` constructs an `ArrayList` from the published Scala `Seq` on every traversal. The reference
Scala `operate` captured the immutable `Seq` and iterated it directly, so this cost is a port artifact rather than a
compatibility requirement.
- Redstone CPU samples are concentrated in Scala `List.foreach` (118/239), `PartMap.edgeBetween` (46/239), iterator
`foreach` (35/239), and the generated strong-power closure (31/239). Allocation events identify
`scala.runtime.IntRef`, Scala iterators, and generated closures as the major sites.
## Decision
The first Phase 4 implementation should target `TileMultipart` traversal, but only after one focused test freezes its
mutation semantics: iteration observes the captured part order, skips a part whose tile was cleared before its turn,
and does not visit a part added during the callback. Then remove the per-call `ArrayList`/array/wrapper materialization
while retaining the public Scala `Seq` and `operate(Function1)` ABI, and re-run this exact profile.
After that comparison, characterize and port the complete `IRedstonePart.scala` unit and eliminate the measured
redstone `IntRef`/closure paths without splitting its load-bearing `RedstoneInteractions$` singleton.
+20
View File
@@ -35,7 +35,11 @@ tasks.register(functionalTestSet.jarTaskName, Jar) {
def functionalTestRunProperty = "forgemultipart.withFunctionalTests"
def withFunctionalTests = providers.gradleProperty(functionalTestRunProperty).map { it.toBoolean() }.orElse(false).get()
def profileRunProperty = "forgemultipart.profileFunctionalTests"
def profileFunctionalTests = providers.gradleProperty(profileRunProperty).map { it.toBoolean() }.orElse(false).get()
def functionalTestReportDirectory = layout.projectDirectory.dir("run/server/junit-out")
def functionalTestProfileRecording = layout.projectDirectory.file("run/server/forgemultipart-baseline.jfr")
def functionalTestProfileResults = layout.projectDirectory.file("run/server/forgemultipart-profile.txt")
def addFunctionalTestsToRun = { JavaExec task ->
task.dependsOn(functionalTestSet.jarTaskName)
task.classpath(
@@ -48,9 +52,15 @@ tasks.register("runFunctionalTestServer", GradleBuild) {
description = "Runs the Java 8 Forge server with the ForgeMultipart functional test mod"
setTasks(["runServer"])
startParameter.projectProperties.put(functionalTestRunProperty, "true")
if (profileFunctionalTests) {
startParameter.projectProperties.put(profileRunProperty, "true")
}
doFirst {
delete(functionalTestReportDirectory)
if (profileFunctionalTests) {
delete(functionalTestProfileRecording, functionalTestProfileResults)
}
}
doLast {
def reports = fileTree(functionalTestReportDirectory).matching { include("TEST-*.xml") }.files
@@ -71,6 +81,10 @@ tasks.register("runFunctionalTestServer", GradleBuild) {
throw new GradleException(
"ForgeMultipart functional tests failed: ${tests} tests, ${failures} failures, ${errors} errors")
}
if (profileFunctionalTests
&& (!functionalTestProfileRecording.asFile.isFile() || !functionalTestProfileResults.asFile.isFile())) {
throw new GradleException("ForgeMultipart profile produced incomplete output")
}
}
}
@@ -78,6 +92,12 @@ if (withFunctionalTests) {
tasks.withType(JavaExec).configureEach { task ->
if (task.name == "runServer") {
addFunctionalTestsToRun(task)
if (profileFunctionalTests) {
task.jvmArgs(
"-XX:+FlightRecorder",
"-XX:StartFlightRecording=filename=forgemultipart-baseline.jfr,settings=profile,dumponexit=true")
task.systemProperty(profileRunProperty, "true")
}
}
}
}
@@ -72,6 +72,10 @@ public final class ForgeMultipartFunctionalTestMod {
MinecraftServer server = MinecraftServer.getServer();
server.addChatMessage(new ChatComponentText("Running ForgeMultipart functional tests..."));
if (Boolean.getBoolean("forgemultipart.profileFunctionalTests")) {
ForgeMultipartProfileWorkload.run();
}
TestExecutionSummary summary = runTests();
if (summary.getTestsFoundCount() == 0) {
throw new IllegalStateException("No ForgeMultipart functional tests were discovered");
@@ -0,0 +1,213 @@
package codechicken.multipart.test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import codechicken.multipart.IRedstonePart;
import codechicken.multipart.IRedstoneTile;
import codechicken.multipart.MultipartHelper;
import codechicken.multipart.TMultiPart;
import codechicken.multipart.TileMultipart;
import scala.runtime.AbstractFunction1;
import scala.runtime.BoxedUnit;
/** Fixed workload used only by the opt-in JFR baseline run. */
final class ForgeMultipartProfileWorkload {
private static final int PART_COUNT = 8;
private static final int WARMUP_ITERATIONS = 1_000_000;
private static final int PROFILE_ITERATIONS = 50_000_000;
private static volatile long sink;
private ForgeMultipartProfileWorkload() {}
static void run() {
List<TMultiPart> tickingParts = new ArrayList<>();
for (int i = 0; i < PART_COUNT; i++) {
tickingParts.add(new ProfilePart());
}
TileMultipart tickingTile = MultipartHelper.createTileFromParts(tickingParts);
List<TMultiPart> redstoneParts = new ArrayList<>();
for (int i = 0; i < PART_COUNT; i++) {
redstoneParts.add(new RedstoneProfilePart(i));
}
TileMultipart redstoneTile = MultipartHelper.createTileFromParts(redstoneParts);
IRedstoneTile redstone = (IRedstoneTile) redstoneTile;
CountingFunction operation = new CountingFunction();
com.sun.management.ThreadMXBean allocationBean = allocationBean();
long threadId = Thread.currentThread().getId();
profileUpdateEntity(tickingTile, WARMUP_ITERATIONS);
profileOperate(tickingTile, operation, WARMUP_ITERATIONS);
profileRedstone(redstoneTile, redstone, WARMUP_ITERATIONS);
long updateStartMillis = System.currentTimeMillis();
long updateStartBytes = allocationBean.getThreadAllocatedBytes(threadId);
long updateStart = System.nanoTime();
profileUpdateEntity(tickingTile, PROFILE_ITERATIONS);
long updateNanos = System.nanoTime() - updateStart;
long updateBytes = allocationBean.getThreadAllocatedBytes(threadId) - updateStartBytes;
long operateStartMillis = System.currentTimeMillis();
long operateStartBytes = allocationBean.getThreadAllocatedBytes(threadId);
long operateStart = System.nanoTime();
profileOperate(tickingTile, operation, PROFILE_ITERATIONS);
long operateNanos = System.nanoTime() - operateStart;
long operateBytes = allocationBean.getThreadAllocatedBytes(threadId) - operateStartBytes;
long redstoneStartMillis = System.currentTimeMillis();
long redstoneStartBytes = allocationBean.getThreadAllocatedBytes(threadId);
long redstoneStart = System.nanoTime();
long redstoneChecksum = profileRedstone(redstoneTile, redstone, PROFILE_ITERATIONS);
long redstoneNanos = System.nanoTime() - redstoneStart;
long redstoneBytes = allocationBean.getThreadAllocatedBytes(threadId) - redstoneStartBytes;
long updateChecksum = 0;
for (TMultiPart part : tickingParts) {
updateChecksum += ((ProfilePart) part).updates;
}
sink = updateChecksum + operation.applications + redstoneChecksum;
writeResults(
updateStartMillis,
updateNanos,
updateBytes,
operateStartMillis,
operateNanos,
operateBytes,
redstoneStartMillis,
redstoneNanos,
redstoneBytes,
sink);
}
private static void profileUpdateEntity(TileMultipart tile, int iterations) {
for (int i = 0; i < iterations; i++) {
tile.updateEntity();
}
}
private static void profileOperate(TileMultipart tile, CountingFunction operation, int iterations) {
for (int i = 0; i < iterations; i++) {
tile.operate(operation);
}
}
private static long profileRedstone(TileMultipart tile, IRedstoneTile redstone, int iterations) {
long checksum = 0;
for (int i = 0; i < iterations; i++) {
int side = i % 6;
checksum += tile.strongPowerLevel(side);
checksum += redstone.getConnectionMask(side);
checksum += redstone.weakPowerLevel(side, 0x1F);
}
return checksum;
}
private static void writeResults(long updateStartMillis, long updateNanos, long updateBytes,
long operateStartMillis, long operateNanos, long operateBytes, long redstoneStartMillis, long redstoneNanos,
long redstoneBytes, long checksum) {
File output = new File("forgemultipart-profile.txt");
try (PrintWriter writer = new PrintWriter(output)) {
writer.printf(Locale.ROOT, "java=%s%n", System.getProperty("java.runtime.version"));
writer.printf(Locale.ROOT, "parts=%d%n", PART_COUNT);
writer.printf(Locale.ROOT, "warmupIterations=%d%n", WARMUP_ITERATIONS);
writer.printf(Locale.ROOT, "profileIterations=%d%n", PROFILE_ITERATIONS);
writeTiming(writer, "updateEntity", updateStartMillis, updateNanos, updateBytes);
writeTiming(writer, "operate", operateStartMillis, operateNanos, operateBytes);
writeTiming(writer, "redstoneQueries", redstoneStartMillis, redstoneNanos, redstoneBytes);
writer.printf(Locale.ROOT, "checksum=%d%n", checksum);
} catch (FileNotFoundException e) {
throw new IllegalStateException("Could not write ForgeMultipart profile results", e);
}
}
private static void writeTiming(PrintWriter writer, String name, long startMillis, long nanos,
long allocatedBytes) {
double seconds = nanos / 1_000_000_000d;
writer.printf(Locale.ROOT, "%s.startEpochMillis=%d%n", name, startMillis);
writer.printf(Locale.ROOT, "%s.nanos=%d%n", name, nanos);
writer.printf(Locale.ROOT, "%s.operationsPerSecond=%.0f%n", name, PROFILE_ITERATIONS / seconds);
writer.printf(Locale.ROOT, "%s.allocatedBytes=%d%n", name, allocatedBytes);
writer.printf(
Locale.ROOT,
"%s.allocatedBytesPerOperation=%.1f%n",
name,
allocatedBytes / (double) PROFILE_ITERATIONS);
}
private static com.sun.management.ThreadMXBean allocationBean() {
java.lang.management.ThreadMXBean bean = ManagementFactory.getThreadMXBean();
if (!(bean instanceof com.sun.management.ThreadMXBean)) {
throw new IllegalStateException("The profiling JVM does not expose thread allocation counters");
}
com.sun.management.ThreadMXBean allocationBean = (com.sun.management.ThreadMXBean) bean;
if (!allocationBean.isThreadAllocatedMemorySupported()) {
throw new IllegalStateException("The profiling JVM does not support thread allocation counters");
}
if (!allocationBean.isThreadAllocatedMemoryEnabled()) {
allocationBean.setThreadAllocatedMemoryEnabled(true);
}
return allocationBean;
}
private static class ProfilePart extends TMultiPart {
private int updates;
@Override
public String getType() {
return "profile_part";
}
@Override
public boolean doesTick() {
return true;
}
@Override
public void update() {
updates++;
}
}
private static final class RedstoneProfilePart extends ProfilePart implements IRedstonePart {
private final int power;
private RedstoneProfilePart(int power) {
this.power = power;
}
@Override
public int strongPowerLevel(int side) {
return power + side;
}
@Override
public int weakPowerLevel(int side) {
return power + side;
}
@Override
public boolean canConnectRedstone(int side) {
return true;
}
}
private static final class CountingFunction extends AbstractFunction1<TMultiPart, BoxedUnit> {
private long applications;
@Override
public BoxedUnit apply(TMultiPart part) {
applications++;
return BoxedUnit.UNIT;
}
}
}