Ghidra is a software reverse engineering (SRE) framework
GP-6550: Fix several issues with R*-Trees causing slowdowns in Trace.
Dan9e4368183d9b
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarDiagnosticsPlugin.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarDiagnosticsPlugin.javanew file mode 100644index 0000000000..8eaf783aa7--- /dev/null+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarDiagnosticsPlugin.java@@ -0,0 +1,93 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package ghidra.app.plugin.core.debug.gui.internal;++import ghidra.app.plugin.PluginCategoryNames;+import ghidra.app.plugin.core.debug.DebuggerPluginPackage;+import ghidra.app.plugin.core.debug.event.TraceActivatedPluginEvent;+import ghidra.debug.api.tracemgr.DebuggerCoordinates;+import ghidra.framework.plugintool.*;+import ghidra.framework.plugintool.util.PluginStatus;+import ghidra.trace.database.memory.DBTraceMemoryManager;+import ghidra.trace.database.memory.DBTraceMemorySpace;+import ghidra.trace.model.Trace;++@PluginInfo(+ shortDescription = "Plot R*-Trees",+ description = "Plot R*-Trees in Trace Databases",+ category = PluginCategoryNames.DIAGNOSTIC,+ packageName = DebuggerPluginPackage.NAME,+ status = PluginStatus.STABLE,+ eventsConsumed = {+ TraceActivatedPluginEvent.class,+ })+public class RStarDiagnosticsPlugin extends Plugin {+ static final int INITIAL_DEPTH = 3;+ static final int MIN_DEPTH = 1;++ protected final RStarPlotProvider plotProvider;+ protected final RStarTreeProvider treeProvider;+ protected DebuggerCoordinates current;+ protected DBTraceMemorySpace space;++ public RStarDiagnosticsPlugin(PluginTool tool) {+ super(tool);+ plotProvider = new RStarPlotProvider(this);+ treeProvider = new RStarTreeProvider(this);+ }++ @Override+ protected void init() {+ super.init();+ tool.addComponentProvider(plotProvider, true);+ tool.addComponentProvider(treeProvider, true);+ }++ @Override+ protected void dispose() {+ tool.removeComponentProvider(plotProvider);+ super.dispose();+ }++ @Override+ public void processEvent(PluginEvent event) {+ super.processEvent(event);+ if (event instanceof TraceActivatedPluginEvent ev) {+ coordinatesActivated(ev.getActiveCoordinates());+ }+ }++ protected DBTraceMemorySpace computeSpace() {+ Trace trace = current.getTrace();+ if (trace == null) {+ return null;+ }+ if (!(trace.getMemoryManager() instanceof DBTraceMemoryManager mem)) {+ return null;+ }+ return mem.getMemorySpace(trace.getBaseAddressFactory().getDefaultAddressSpace(), false);+ }++ protected void coordinatesActivated(DebuggerCoordinates current) {+ this.current = current;+ this.space = computeSpace();+ if (space == null) {+ plotProvider.bounds = null;+ }+ plotProvider.component.repaint();+ treeProvider.refresh();+ }+}diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarPlotProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarPlotProvider.javanew file mode 100644index 0000000000..efd1526bf7--- /dev/null+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarPlotProvider.java@@ -0,0 +1,321 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package ghidra.app.plugin.core.debug.gui.internal;++import java.awt.*;+import java.awt.event.*;+import java.util.Arrays;+import java.util.List;++import javax.swing.JComponent;+import javax.swing.JPanel;+import javax.swing.tree.TreePath;++import docking.action.builder.ActionBuilder;+import generic.theme.GIcon;+import ghidra.app.plugin.core.debug.gui.internal.RStarTreeProvider.HasShape;+import ghidra.framework.plugintool.ComponentProviderAdapter;+import ghidra.program.model.address.AddressSpace;+import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.Painter;+import ghidra.trace.model.*;+import ghidra.util.database.spatial.DBTreeDataRecord;++public class RStarPlotProvider extends ComponentProviderAdapter {+ private final RStarDiagnosticsPlugin plugin;++ final JComponent component = new JPanel(true) {+ @Override+ public void paint(Graphics g) {+ super.paint(g);+ RStarPlotProvider.this.doPaint(g);+ }+ };++ private int depth = RStarDiagnosticsPlugin.INITIAL_DEPTH;++ TraceAddressSnapRange bounds;+ private int mouseX;+ private int mouseY;++ private boolean didDrag;+ private int begDragX;+ private int begDragY;+ private int endDragX;+ private int endDragY;++ public RStarPlotProvider(RStarDiagnosticsPlugin plugin) {+ super(plugin.getTool(), "R*-Tree Diagnostic Plot", plugin.getName());+ this.plugin = plugin;+ updateSubtitle();+ component.addComponentListener(new ComponentAdapter() {+ @Override+ public void componentResized(ComponentEvent e) {+ component.repaint();+ }++ @Override+ public void componentShown(ComponentEvent e) {+ component.repaint();+ }+ });++ component.addMouseWheelListener(new MouseWheelListener() {+ @Override+ public void mouseWheelMoved(MouseWheelEvent e) {+ if (plugin.space == null) {+ return;+ }+ int maxDepth = plugin.space.getDepth();+ int newDepth =+ Math.min(+ Math.max(depth + e.getWheelRotation(), RStarDiagnosticsPlugin.MIN_DEPTH),+ maxDepth);+ if (newDepth == depth) {+ return;+ }+ depth = newDepth;+ updateSubtitle();+ component.repaint();+ }+ });+ component.addMouseMotionListener(new MouseMotionAdapter() {+ @Override+ public void mouseMoved(MouseEvent e) {+ if (plugin.space == null) {+ return;+ }+ OffsetSnap offsetSnap = xyToOffsetSnap(e.getX(), e.getY());+ if (offsetSnap == null) {+ return;+ }+ tool.setStatusInfo(offsetSnap.toString());+ }++ @Override+ public void mouseDragged(MouseEvent e) {+ didDrag = true;+ }+ });+ component.addMouseListener(new MouseAdapter() {+ @Override+ public void mouseClicked(MouseEvent e) {+ if (e.getButton() == 1) {+ mouseX = e.getX();+ mouseY = e.getY();+ component.repaint();+ }+ else if (e.getButton() == 3) {+ if (plugin.space == null) {+ bounds = null;+ }+ else {+ bounds = plugin.space.getRootBounds();+ }+ component.repaint();+ }+ }++ @Override+ public void mousePressed(MouseEvent e) {+ didDrag = false;+ begDragX = e.getX();+ begDragY = e.getY();+ }++ @Override+ public void mouseReleased(MouseEvent e) {+ if (!didDrag) {+ return;+ }+ endDragX = e.getX();+ endDragY = e.getY();+ if (endDragX == begDragX || endDragY == begDragY) {+ return;+ }+ if (endDragX < begDragX) {+ int t = endDragX;+ endDragX = begDragX;+ begDragX = t;+ }+ if (endDragY < begDragY) {+ int t = endDragY;+ endDragY = begDragY;+ begDragY = t;+ }+ Trace trace = plugin.current.getTrace();+ if (trace == null) {+ return;+ }+ AddressSpace addrSpace = trace.getBaseAddressFactory().getDefaultAddressSpace();+ OffsetSnap beg = xyToOffsetSnap(begDragX, begDragY);+ OffsetSnap end = xyToOffsetSnap(endDragX, endDragY);+ bounds =+ new ImmutableTraceAddressSnapRange(addrSpace.getAddress(beg.offset),+ addrSpace.getAddress(end.offset), beg.snap, end.snap);+ component.repaint();+ }+ });+ new ActionBuilder("Zoom Out", plugin.getName())+ .toolBarIcon(new GIcon("icon.debugger.breakpoint.timeline.zoom_out_max"))+ .onAction(ctx -> {+ if (plugin.space == null) {+ bounds = null;+ }+ else {+ bounds = plugin.space.getRootBounds();+ }+ })+ .buildAndInstallLocal(this);+ }++ record OffsetSnap(long offset, long snap) {+ @Override+ public final String toString() {+ return "Addr:%08x,Snap:%d".formatted(offset, snap);+ }+ }++ protected OffsetSnap xyToOffsetSnap(int x, int y) {+ if (bounds == null) {+ return null;+ }+ double scaleX =+ 1.0 * (bounds.getX2().getOffset() - bounds.getX1().getOffset()) /+ component.getWidth();+ double scaleY = 1.0 * (bounds.getY2() - bounds.getY1()) / component.getHeight();++ long offset = bounds.getX1().getOffset() + (long) (scaleX * x);+ long snap = bounds.getY1() + (long) (scaleY * y);+ return new OffsetSnap(offset, snap);+ }++ protected void updateSubtitle() {+ if (plugin.space == null) {+ setSubTitle("");+ return;+ }+ setSubTitle("Depth=%d,Max=%d".formatted(depth, plugin.space.getDepth()));+ }++ @Override+ public JComponent getComponent() {+ return component;+ }++ private abstract class MyPainter implements Painter {+ private final double xScale;+ private final double yScale;+ private final long xShift;+ private final long yShift;++ public MyPainter(Rectangle rect, TraceAddressSnapRange bounds) {+ xScale = 1.0 * rect.width / (bounds.getX2().getOffset() - bounds.getX1().getOffset());+ yScale = 1.0 * rect.height / (bounds.getY2() - bounds.getY1());+ xShift = bounds.getX1().getOffset();+ yShift = bounds.getY1();+ }++ @Override+ public void paint(TraceAddressSnapRange shape, int depth) {+ int x = (int) ((shape.getX1().getOffset() - xShift) * xScale);+ int y = (int) ((shape.getY1() - yShift) * yScale);++ int width = Math.max(1,+ (int) ((shape.getX2().getOffset() - shape.getX1().getOffset()) * xScale));+ int height = Math.max(1, (int) ((shape.getY2() - shape.getY1()) * yScale));++ paintRect(x, y, width, height, shape, depth);+ }++ protected abstract void paintRect(int x, int y, int width, int height,+ TraceAddressSnapRange shape, int depth);+ }++ void doPaint(Graphics _g) {+ if (!(_g instanceof Graphics2D g)) {+ return;+ }+ Rectangle r = new Rectangle(0, 0, component.getWidth(), component.getHeight());+ g.clearRect(r.x, r.y, r.width, r.height);+ if (plugin.space == null) {+ return;+ }+ if (bounds == null) {+ bounds = plugin.space.getRootBounds();+ }++ var fillPainter = new MyPainter(r, bounds) {+ TraceAddressSnapRange result;++ @Override+ protected void paintRect(int x, int y, int width, int height,+ TraceAddressSnapRange shape, int depth) {+ boolean select = x <= mouseX && mouseX <= x + width &&+ y <= mouseY && mouseY <= y + height;+ float brightness = (float) Math.pow(0.5, depth);+ if (select) {+ result = shape;+ g.setColor(shape instanceof DBTreeDataRecord<?, ?, ?>+ ? new Color(0, brightness, 0)+ : new Color(0, brightness, brightness));+ }+ else {+ g.setColor(shape instanceof DBTreeDataRecord<?, ?, ?>+ ? new Color(brightness, brightness, 0)+ : new Color(brightness, brightness, brightness));+ }+ g.fillRect(x, y, width, height);+ }+ };+ var linePainter = new MyPainter(r, bounds) {+ @Override+ protected void paintRect(int x, int y, int width, int height,+ TraceAddressSnapRange shape, int depth) {+ g.setColor(shape instanceof DBTreeDataRecord<?, ?, ?>+ ? Color.RED+ : Color.BLACK);+ g.drawRect(x, y, width, height);+ }+ };++ TreePath[] selArr = plugin.treeProvider.tree.getSelectionPaths();+ if (selArr == null || selArr.length == 0) {+ plugin.space.paint(fillPainter, depth);+ plugin.space.paint(linePainter, depth);+ if (fillPainter.result != null) {+ plugin.treeProvider.select(fillPainter.result);+ }+ }++ List<TreePath> selection = Arrays.asList(selArr);+ selection.sort((p1, p2) -> {+ return p1.getPathCount() - p2.getPathCount();+ });+ g.setColor(Color.CYAN);+ for (TreePath p : selection) {+ if (!(p.getLastPathComponent() instanceof HasShape node)) {+ continue;+ }+ fillPainter.paint(node.getShape(), p.getPathCount() - 1);+ }+ for (TreePath p : selection) {+ if (!(p.getLastPathComponent() instanceof HasShape node)) {+ continue;+ }+ linePainter.paint(node.getShape(), p.getPathCount() - 1);+ }+ }+}diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarTreeProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarTreeProvider.javanew file mode 100644index 0000000000..a7055008b5--- /dev/null+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/internal/RStarTreeProvider.java@@ -0,0 +1,196 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package ghidra.app.plugin.core.debug.gui.internal;++import java.awt.BorderLayout;+import java.util.*;++import javax.swing.*;++import docking.widgets.tree.*;+import generic.theme.GIcon;+import ghidra.framework.plugintool.ComponentProviderAdapter;+import ghidra.trace.model.TraceAddressSnapRange;+import ghidra.util.database.spatial.*;++public class RStarTreeProvider extends ComponentProviderAdapter {+ private final RStarDiagnosticsPlugin plugin;++ interface HasShape {+ TraceAddressSnapRange getShape();+ }++ class RootRStarNode extends GTreeLazyNode implements HasShape {+ static final GIcon ICON = new GIcon("blargh");++ @Override+ public TraceAddressSnapRange getShape() {+ if (plugin == null || plugin.space == null) {+ return null;+ }+ return plugin.space.getRootBounds();+ }++ @Override+ public String getName() {+ TraceAddressSnapRange root = getShape();+ if (root == null) {+ return "No Shape";+ }+ return root.toString();+ }++ @Override+ public Icon getIcon(boolean expanded) {+ return ICON;+ }++ @Override+ public String getToolTip() {+ return null;+ }++ @Override+ public boolean isLeaf() {+ return false;+ }++ @Override+ protected List<GTreeNode> generateChildren() {+ if (!(getShape() instanceof DBTreeNodeRecord<?> rec)) {+ return List.of();+ }+ return plugin.space.getChildrenOf(rec).stream().map(n -> nodeFor(n)).toList();+ }+ }++ class NodeRStarNode extends GTreeLazyNode implements HasShape {+ static final GIcon ICON = new GIcon("blargh");+ final DBTreeNodeRecord<?> rec;++ public NodeRStarNode(DBTreeNodeRecord<?> rec) {+ this.rec = rec;+ }++ @Override+ public TraceAddressSnapRange getShape() {+ return (TraceAddressSnapRange) rec.getShape();+ }++ @Override+ public String getName() {+ return rec.toString();+ }++ @Override+ public Icon getIcon(boolean expanded) {+ return ICON;+ }++ @Override+ public String getToolTip() {+ return null;+ }++ @Override+ public boolean isLeaf() {+ return false;+ }++ @Override+ protected List<GTreeNode> generateChildren() {+ return plugin.space.getChildrenOf(rec).stream().map(n -> nodeFor(n)).toList();+ }+ }++ class DataRStarNode extends GTreeNode implements HasShape {+ static final GIcon ICON = new GIcon("blargh");+ final DBTreeDataRecord<?, ?, ?> rec;++ public DataRStarNode(DBTreeDataRecord<?, ?, ?> rec) {+ this.rec = rec;+ }++ @Override+ public TraceAddressSnapRange getShape() {+ return (TraceAddressSnapRange) rec.getShape();+ }++ @Override+ public String getName() {+ return rec.toString();+ }++ @Override+ public Icon getIcon(boolean expanded) {+ return ICON;+ }++ @Override+ public String getToolTip() {+ return null;+ }++ @Override+ public boolean isLeaf() {+ return true;+ }+ }++ final Map<DBTreeRecord<?, ?>, GTreeNode> nodes = new HashMap<>();++ private GTreeNode nodeFor(DBTreeRecord<?, ?> rec) {+ if (rec == plugin.space.getRootBounds()) {+ return root;+ }+ return nodes.computeIfAbsent(rec, r -> switch (rec) {+ case DBTreeNodeRecord<?> n -> new NodeRStarNode(n);+ case DBTreeDataRecord<?, ?, ?> d -> new DataRStarNode(d);+ default -> throw new AssertionError();+ });+ }++ final RootRStarNode root = new RootRStarNode();+ final GTree tree = new GTree(root);+ final JPanel panel = new JPanel(new BorderLayout());++ public RStarTreeProvider(RStarDiagnosticsPlugin plugin) {+ super(plugin.getTool(), "R*-Tree Diagnostic Tree", plugin.getName());+ this.plugin = plugin;+ this.panel.add(tree);++ tree.addGTreeSelectionListener(e -> {+ plugin.plotProvider.component.repaint();+ });+ }++ @Override+ public JComponent getComponent() {+ return panel;+ }++ public void select(TraceAddressSnapRange shape) {+ if (!(shape instanceof DBTreeRecord<?, ?> rec)) {+ return;+ }+ tree.getSelectionModel().setSelectionPath(nodeFor(rec).getTreePath());+ }++ void refresh() {+ root.unloadChildren();+ nodes.clear();+ }+}diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerSnapshotTablePanel.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerSnapshotTablePanel.javaindex 939b5b391d..bbf4a1c9ae 100644--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerSnapshotTablePanel.java+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerSnapshotTablePanel.java@@ -471,10 +471,11 @@ public class DebuggerSnapshotTablePanel extends JPanel {}public void setCurrent(DebuggerCoordinates coords) {+ assert coords.getTrace() == currentTrace;boolean fire = coords.getViewSnap() != current.getViewSnap();current = coords;if (fire) {- snapshotTableModel.fireTableDataChanged();+ snapshotTable.repaint();}}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceTimeViewport.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceTimeViewport.javaindex fad17ba9ba..71878993be 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceTimeViewport.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTraceTimeViewport.java@@ -27,7 +27,6 @@ import ghidra.trace.model.Lifespan.MutableLifeSet;import ghidra.trace.model.program.TraceProgramView;import ghidra.trace.model.time.TraceSnapshot;import ghidra.trace.model.time.TraceTimeManager;-import ghidra.trace.model.time.schedule.TraceSchedule;import ghidra.util.*;import ghidra.util.datastruct.ListenerSet;@@ -161,31 +160,6 @@ public class DBTraceTimeViewport implements TraceTimeViewport {return true;}- protected static TraceSnapshot locateMostRecentFork(TraceTimeManager timeManager, long from) {- while (true) {- TraceSnapshot prev = timeManager.getMostRecentSnapshot(from);- if (prev == null) {- return null;- }- TraceSchedule prevSched = prev.getSchedule();- long prevKey = prev.getKey();- if (prevSched == null) {- if (prevKey == Long.MIN_VALUE) {- return null;- }- from = prevKey - 1;- continue;- }- long forkedSnap = prevSched.getSnap();- if (forkedSnap == prevKey - 1) {- // Schedule is notational without forking- from--;- continue;- }- return prev;- }- }-/*** Construct the ranges (set and ordered)*@@ -200,14 +174,11 @@ public class DBTraceTimeViewport implements TraceTimeViewport {protected static void collectForkRanges(TraceTimeManager timeManager, long curSnap,MutableLifeSet spanSet, List<Lifespan> ordered) {while (true) {- TraceSnapshot fork = locateMostRecentFork(timeManager, curSnap);- long prevSnap = fork == null ? Long.MIN_VALUE : fork.getKey();- if (curSnap >= 0 && prevSnap < 0) {- prevSnap = 0;- }+ long prevSnap = timeManager.getMostRecentFork(curSnap);if (!addSnapRange(prevSnap, curSnap, spanSet, ordered)) {return;}+ TraceSnapshot fork = timeManager.getSnapshot(prevSnap, false);if (fork == null) {return;}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpace.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpace.javaindex 27b71332b6..3252074ddc 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpace.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpace.java@@ -25,18 +25,17 @@ import ghidra.lifecycle.Internal;import ghidra.program.model.address.*;import ghidra.trace.database.DBTrace;import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMap.DBTraceAddressSnapRangePropertyMapDataFactory;-import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;-import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;+import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.*;import ghidra.trace.database.space.DBTraceSpaceBased;import ghidra.trace.model.*;import ghidra.trace.model.map.TraceAddressSnapRangePropertyMapSpace;import ghidra.util.LockHold;import ghidra.util.database.*;-import ghidra.util.database.spatial.AbstractConstraintsTreeSpatialMap;-import ghidra.util.database.spatial.SpatialMap;+import ghidra.util.database.spatial.*;import ghidra.util.exception.VersionException;-public class DBTraceAddressSnapRangePropertyMapSpace<T, DR extends AbstractDBTraceAddressSnapRangePropertyMapData<T>>+public class DBTraceAddressSnapRangePropertyMapSpace<T,+ DR extends AbstractDBTraceAddressSnapRangePropertyMapData<T>>implements DBTraceSpaceBased,SpatialMap<TraceAddressSnapRange, T, TraceAddressSnapRangeQuery>,TraceAddressSnapRangePropertyMapSpace<T> {@@ -45,7 +44,8 @@ public class DBTraceAddressSnapRangePropertyMapSpace<T, DR extends AbstractDBTraprotected final AddressSpace space;protected final ReadWriteLock lock;protected final DBTraceAddressSnapRangePropertyMapTree<T, DR> tree;- protected final AbstractConstraintsTreeSpatialMap<TraceAddressSnapRange, DR, TraceAddressSnapRange, T, TraceAddressSnapRangeQuery> map;+ protected final AbstractConstraintsTreeSpatialMap<TraceAddressSnapRange, DR,+ TraceAddressSnapRange, T, TraceAddressSnapRangeQuery> map;protected final AddressRangeImpl fullSpace;public DBTraceAddressSnapRangePropertyMapSpace(String tableName, DBTrace trace,@@ -205,4 +205,37 @@ public class DBTraceAddressSnapRangePropertyMapSpace<T, DR extends AbstractDBTrapublic void checkIntegrity() {tree.checkIntegrity();}++ /**+ * For developers and testers.+ */+ @Internal+ public void paint(Painter painter, int depth) {+ tree.paint(painter, depth);+ }++ /**+ * For developers and testers.+ */+ @Internal+ public int getDepth() {+ return tree.getDepth();+ }++ /**+ * For developers and testers.+ */+ @Internal+ public TraceAddressSnapRange getRootBounds() {+ return tree.getRootBounds();+ }++ /**+ * For developers and testers.+ */+ @Internal+ public Collection<? extends DBTreeRecord<?, ? extends TraceAddressSnapRange>>+ getChildrenOf(DBTreeNodeRecord<?> rec) {+ return tree.internalGetChildrenOf(rec);+ }}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapTree.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapTree.javaindex 05689db55a..0411587e7f 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapTree.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapTree.java@@ -19,14 +19,15 @@ import java.io.IOException;import java.util.*;import db.DBRecord;+import ghidra.lifecycle.Internal;import ghidra.program.model.address.*;import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMap.DBTraceAddressSnapRangePropertyMapDataFactory;import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.*;import ghidra.trace.model.*;import ghidra.util.database.*;import ghidra.util.database.annot.*;-import ghidra.util.database.spatial.DBTreeDataRecord;-import ghidra.util.database.spatial.DBTreeNodeRecord;+import ghidra.util.database.spatial.*;+import ghidra.util.database.spatial.Query.QueryInclusion;import ghidra.util.database.spatial.rect.*;import ghidra.util.exception.VersionException;@@ -666,4 +667,98 @@ public class DBTraceAddressSnapRangePropertyMapTree<T,public DBTraceAddressSnapRangePropertyMapSpace<T, DR> getMapSpace() {return mapSpace;}++ public interface Painter {+ void paint(TraceAddressSnapRange shape, int depth);+ }++ /**+ * For developers and testers.+ */+ @Internal+ public void paint(Painter painter, int depth) {+ var visitor = new TreeRecordVisitor() {+ int depth = 0;+ int level = 0;++ @Override+ protected VisitResult beginNode(DBTraceAddressSnapRangePropertyMapNode parent,+ DBTraceAddressSnapRangePropertyMapNode n, QueryInclusion inclusion) {+ if (level == depth) {+ painter.paint(n, depth);+ }+ if (level > depth) {+ return VisitResult.NEXT;+ }+ level++;+ return VisitResult.DESCEND;+ }++ @Override+ protected VisitResult endNode(DBTraceAddressSnapRangePropertyMapNode parent,+ DBTraceAddressSnapRangePropertyMapNode n, QueryInclusion inclusion) {+ level--;+ return super.endNode(parent, n, inclusion);+ }++ @Override+ protected VisitResult visitData(DBTraceAddressSnapRangePropertyMapNode parent, DR d,+ boolean included) {+ painter.paint(d, depth);+ return VisitResult.NEXT;+ }+ };++ for (int i = 0; i < depth; i++) {+ visitor.depth = i;+ visit(null, visitor, false);+ }+ }++ /**+ * For developers and testers.+ */+ @Internal+ public int getDepth() {+ return leafLevel + 2;+ }++ /**+ * For developers and testers.+ */+ @Internal+ public TraceAddressSnapRange getRootBounds() {+ return root;+ }++ /**+ * For developers and testers.+ */+ @Internal+ public Collection<? extends DBTreeRecord<?, ? extends TraceAddressSnapRange>>+ internalGetChildrenOf(DBTreeNodeRecord<?> rec) {+ if (!(rec instanceof DBTraceAddressSnapRangePropertyMapNode node)) {+ return List.of();+ }+ return getChildrenOf(node);+ }++ @Override // expose for testing+ protected Comparator<TraceAddressSnapRange>+ doChooseSplitAxis(List<DBTreeRecord<?, ? extends TraceAddressSnapRange>> children) {+ return super.doChooseSplitAxis(children);+ }++ @Override // expose for testing+ protected int doChooseSplitIndex(+ List<DBTreeRecord<?, ? extends TraceAddressSnapRange>> children,+ Comparator<TraceAddressSnapRange> axis) {+ return super.doChooseSplitIndex(children, axis);+ }++ @Override // expose for testing+ protected Collection<? extends DBTreeRecord<?, ? extends TraceAddressSnapRange>>+ getChildrenOf(DBTraceAddressSnapRangePropertyMapNode parent) {+ return super.getChildrenOf(parent);+ }}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemorySpace.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemorySpace.javaindex 0b8047496d..7e9899a84d 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemorySpace.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemorySpace.java@@ -24,6 +24,7 @@ import java.util.concurrent.locks.ReadWriteLock;import java.util.function.Predicate;import db.DBHandle;+import ghidra.lifecycle.Internal;import ghidra.program.model.address.*;import ghidra.program.model.mem.MemBuffer;import ghidra.trace.database.DBTrace;@@ -32,6 +33,7 @@ import ghidra.trace.database.DBTraceUtils.AddressRangeMapSetter;import ghidra.trace.database.DBTraceUtils.OffsetSnap;import ghidra.trace.database.listing.DBTraceCodeSpace;import ghidra.trace.database.map.*;+import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.Painter;import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager.DBTraceSpaceEntry;import ghidra.trace.database.space.DBTraceSpaceBased;@@ -43,6 +45,8 @@ import ghidra.trace.util.TraceEvents;import ghidra.util.*;import ghidra.util.AddressIteratorAdapter;import ghidra.util.database.*;+import ghidra.util.database.spatial.DBTreeNodeRecord;+import ghidra.util.database.spatial.DBTreeRecord;import ghidra.util.database.spatial.rect.Rectangle2DDirection;import ghidra.util.datastruct.FixedSizeHashMap;import ghidra.util.exception.VersionException;@@ -66,7 +70,8 @@ public class DBTraceMemorySpaceprotected final ReadWriteLock lock;protected final DBTrace trace;- protected final DBTraceAddressSnapRangePropertyMapSpace<TraceMemoryState, DBTraceMemoryStateEntry> stateMapSpace;+ protected final DBTraceAddressSnapRangePropertyMapSpace<TraceMemoryState,+ DBTraceMemoryStateEntry> stateMapSpace;protected final DBCachedObjectStore<DBTraceMemoryBufferEntry> bufferStore;protected final DBCachedObjectStore<DBTraceMemoryBlockEntry> blockStore;@@ -135,7 +140,9 @@ public class DBTraceMemorySpacevar l = new Object() {boolean changed;};- new AddressRangeMapSetter<Entry<TraceAddressSnapRange, TraceMemoryState>, TraceMemoryState>() {+ new AddressRangeMapSetter<Entry<TraceAddressSnapRange, TraceMemoryState>,+ TraceMemoryState>() {+@Overrideprotected AddressRange getRange(Entry<TraceAddressSnapRange, TraceMemoryState> entry) {return entry.getKey().getRange();@@ -316,6 +323,7 @@ public class DBTraceMemorySpaceif (predicate.test(entry.getValue())) {result.add(foundRange);}+ break;}}return result;@@ -324,7 +332,7 @@ public class DBTraceMemorySpaceprotected Collection<Entry<TraceAddressSnapRange, TraceMemoryState>> doGetStates(Lifespan span,AddressRange range) {- // TODO: A better way to handle memory-mapped registers?+ // LATER: A better way to handle memory-mapped registers?if (getAddressSpace().isRegisterSpace() && !range.getAddressSpace().isRegisterSpace()) {return trace.getMemoryManager().doGetStates(span, range);}@@ -603,11 +611,11 @@ public class DBTraceMemorySpace@Overridepublic int getViewBytes(long snap, Address start, ByteBuffer buf) {assertInSpace(start);- AddressRange toRead;int len = truncateLen(buf.remaining(), start);if (len == 0) {return 0;}+ AddressRange toRead;try {toRead = new AddressRangeImpl(start, len);}@@ -912,4 +920,37 @@ public class DBTraceMemorySpaceblockCacheMostRecent.clear();}}++ /**+ * For developers and testers.+ */+ @Internal+ public void paint(Painter painter, int depth) {+ stateMapSpace.paint(painter, depth);+ }++ /**+ * For developers and testers.+ */+ @Internal+ public int getDepth() {+ return stateMapSpace.getDepth();+ }++ /**+ * For developers and testers.+ */+ @Internal+ public TraceAddressSnapRange getRootBounds() {+ return stateMapSpace.getRootBounds();+ }++ /**+ * For developers and testers.+ */+ @Internal+ public Collection<? extends DBTreeRecord<?, ? extends TraceAddressSnapRange>>+ getChildrenOf(DBTreeNodeRecord<?> rec) {+ return stateMapSpace.getChildrenOf(rec);+ }}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ImmutableValueBox.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ImmutableValueBox.javaindex f00e6ff44b..60715f1dd5 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ImmutableValueBox.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ImmutableValueBox.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -16,6 +16,10 @@package ghidra.trace.database.target;record ImmutableValueBox(ValueTriple lCorner, ValueTriple uCorner) implements ValueBox {+ ImmutableValueBox {+ assert lCorner.snap() <= uCorner.snap();+ }+public ImmutableValueBox(ValueBox box) {this(box.lCorner(), box.uCorner());}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ValueSpace.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ValueSpace.javaindex 861c9a7a3e..f0841a1292 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ValueSpace.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/ValueSpace.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -96,10 +96,10 @@ enum ValueSpace implements EuclideanHyperSpace<ValueTriple, ValueBox> {}@Override- public double distance(RecAddress a, RecAddress b) {- double result = b.spaceId() - a.spaceId();+ public double distance(RecAddress upper, RecAddress lower) {+ double result = upper.spaceId() - lower.spaceId();result *= Math.pow(2, 64);- result += (b.offset() - a.offset());+ result += (upper.offset() - lower.offset());return result;}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceSnapshot.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceSnapshot.javaindex 290087089b..564acfdddd 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceSnapshot.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceSnapshot.java@@ -19,6 +19,7 @@ import java.io.IOException;import db.DBRecord;import ghidra.trace.database.target.DBTraceObject;+import ghidra.trace.database.time.DBTraceTimeManager.DBTraceFork;import ghidra.trace.model.Trace;import ghidra.trace.model.target.TraceObject;import ghidra.trace.model.target.TraceObjectValue;@@ -68,6 +69,7 @@ public class DBTraceSnapshot extends DBAnnotatedObject implements TraceSnapshotprivate TraceThread eventThread;private TraceSchedule schedule;+ private boolean isFork;public DBTraceSnapshot(DBTraceTimeManager manager, DBCachedObjectStore<?> store,DBRecord record) {@@ -80,6 +82,7 @@ public class DBTraceSnapshot extends DBAnnotatedObject implements TraceSnapshotif (created) {threadKey = -1;scheduleStr = "";+ isFork = false;}else {eventThread = manager.threadManager.getThread(threadKey);@@ -92,9 +95,20 @@ public class DBTraceSnapshot extends DBAnnotatedObject implements TraceSnapshot// Leave as null (or previous value?)}}+ isFork = computeIsFork();}}+ protected boolean computeIsFork() {+ if (key == Long.MIN_VALUE) {+ return false;+ }+ if (schedule == null) {+ return false;+ }+ return schedule.getSnap() != key - 1;+ }+@Overridepublic String toString() {return String.format(@@ -201,12 +215,29 @@ public class DBTraceSnapshot extends DBAnnotatedObject implements TraceSnapshot}}+ @Override+ public boolean isFork() {+ try (LockHold hold = LockHold.lock(manager.lock.readLock())) {+ return isFork;+ }+ }+@Overridepublic void setSchedule(TraceSchedule schedule) {try (LockHold hold = LockHold.lock(manager.lock.writeLock())) {this.schedule = schedule;this.scheduleStr = schedule == null ? "" : schedule.toString(TimeRadix.DEC);+ this.isFork = computeIsFork();update(SCHEDULE_COLUMN);++ DBTraceFork foundFork = manager.forksBySnap.getOne(key);+ if (foundFork != null && !isFork) {+ manager.forkStore.delete(foundFork);+ }+ else if (foundFork == null && isFork) {+ manager.forkStore.create().set(key);+ }+manager.notifySnapshotChanged(this);}}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceTimeManager.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceTimeManager.javaindex 6588ea8e38..4cf65d1f6b 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceTimeManager.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceTimeManager.java@@ -21,6 +21,7 @@ import java.util.Map.Entry;import java.util.concurrent.locks.ReadWriteLock;import db.DBHandle;+import db.DBRecord;import ghidra.framework.data.OpenMode;import ghidra.trace.database.DBTrace;import ghidra.trace.database.DBTraceManager;@@ -36,11 +37,34 @@ import ghidra.trace.util.TraceChangeRecord;import ghidra.trace.util.TraceEvents;import ghidra.util.LockHold;import ghidra.util.database.*;+import ghidra.util.database.annot.*;import ghidra.util.exception.VersionException;import ghidra.util.task.TaskMonitor;public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {+ @DBAnnotatedObjectInfo(version = 0)+ public static class DBTraceFork extends DBAnnotatedObject {+ protected static final String TABLE_NAME = "Forks";++ protected static final String SNAP_COLUMN_NAME = "Snap";++ @DBAnnotatedColumn(SNAP_COLUMN_NAME)+ static DBObjectColumn SNAP_COLUMN;++ @DBAnnotatedField(column = SNAP_COLUMN_NAME, indexed = true)+ long snap;++ public DBTraceFork(DBCachedObjectStore<?> store, DBRecord record) {+ super(store, record);+ }++ protected void set(long snap) {+ this.snap = snap;+ update(SNAP_COLUMN);+ }+ }+protected final ReadWriteLock lock;protected final DBTrace trace;protected final DBTraceThreadManager threadManager;@@ -48,6 +72,9 @@ public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {protected final DBCachedObjectStore<DBTraceSnapshot> snapshotStore;protected final DBCachedObjectIndex<String, DBTraceSnapshot> snapshotsBySchedule;+ protected final DBCachedObjectStore<DBTraceFork> forkStore;+ protected final DBCachedObjectIndex<Long, DBTraceFork> forksBySnap;+public DBTraceTimeManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,TaskMonitor monitor, DBTrace trace, DBTraceThreadManager threadManager)throws VersionException, IOException {@@ -60,6 +87,10 @@ public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {snapshotStore = factory.getOrCreateCachedStore(DBTraceSnapshot.TABLE_NAME,DBTraceSnapshot.class, (s, r) -> new DBTraceSnapshot(this, s, r), true);snapshotsBySchedule = snapshotStore.getIndex(String.class, DBTraceSnapshot.SCHEDULE_COLUMN);++ forkStore = factory.getOrCreateCachedStore(DBTraceFork.TABLE_NAME, DBTraceFork.class,+ DBTraceFork::new, true);+ forksBySnap = forkStore.getIndex(long.class, DBTraceFork.SNAP_COLUMN);}@Override@@ -131,6 +162,23 @@ public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {}}+ @Override+ public long getMostRecentFork(long snap) {+ try (LockHold hold = LockHold.lock(lock.readLock())) {+ Entry<Long, DBTraceFork> foundFork = forksBySnap.floorEntry(snap);+ if (foundFork == null) {+ if (snap < 0) {+ return Long.MIN_VALUE;+ }+ return 0;+ }+ if (foundFork.getKey() < 0 && snap >= 0) {+ return 0;+ }+ return foundFork.getValue().snap;+ }+ }+@Overridepublic Collection<? extends TraceSnapshot> getSnapshotsWithSchedule(TraceSchedule schedule) {return snapshotsBySchedule.get(schedule.toString());@@ -269,7 +317,11 @@ public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {public void deleteSnapshot(DBTraceSnapshot snapshot) {try (LockHold hold = LockHold.lock(lock.writeLock())) {+ DBTraceFork foundFork = forksBySnap.getOne(snapshot.getKey());snapshotStore.delete(snapshot);+ if (foundFork != null) {+ forkStore.delete(foundFork);+ }notifySnapshotDeleted(snapshot);}}diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceSnapshot.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceSnapshot.javaindex d691d4ed06..fd2575f65a 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceSnapshot.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceSnapshot.java@@ -108,6 +108,19 @@ public interface TraceSnapshot {*/String getScheduleString();+ /**+ * Check whether this snapshot represents a fork+ *+ * <p>+ * A snapshot is a fork if the snap immediately preceding it does not actually represents its+ * immediately preceding snapshot in time. This is the case if the snapshot has a schedule whose+ * initial snapshot is not the one immediately preceding it. NOTE: The (scratch) snapshot with+ * the minimum key is <em>not</em> considered a fork.+ *+ * @return true if a fork, false otherwise+ */+ public boolean isFork();+/*** Set the schedule from some previous snapshot to this one*diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceTimeManager.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceTimeManager.javaindex 498dab653d..e291f8c95a 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceTimeManager.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/time/TraceTimeManager.java@@ -50,6 +50,22 @@ public interface TraceTimeManager {*/TraceSnapshot getMostRecentSnapshot(long snap);+ /**+ * Get the most recent fork snapshot key since a given key+ *+ * <p>+ * This searches the snapshots for one where {@link TraceSnapshot#isFork()} is true. Note that+ * conventionally, negative snaps are <em>scratch</em> space. If a non-negative snap is given,+ * then the return fork snap must also be non-negative, i.e., if no non-negative fork snapshot+ * is found, this will return 0, the initial snapshot. If a negative snap is given, then the+ * return fork snap must also be negative, i.e., if no negative fork snapshot is found, this+ * will return {@value Long#MIN_VALUE}, even if that snapshot does not actually exist.+ *+ * @param snap the snapshot key+ * @return the fork snapshot key+ */+ long getMostRecentFork(long snap);+/*** Get all snapshots with the given schedule*diff --git a/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpaceTest.java b/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpaceTest.javaindex 4033dc8fa6..eb18ad6ab0 100644--- a/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpaceTest.java+++ b/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpaceTest.java@@ -26,6 +26,8 @@ import java.util.*;import java.util.Map.Entry;import org.apache.commons.lang3.tuple.ImmutablePair;+import org.hamcrest.MatcherAssert;+import org.hamcrest.Matchers;import org.junit.*;import db.*;@@ -42,7 +44,10 @@ import ghidra.trace.model.TraceAddressSnapRange;import ghidra.util.LockHold;import ghidra.util.database.*;import ghidra.util.database.annot.*;+import ghidra.util.database.spatial.DBTreeRecord;import ghidra.util.database.spatial.SpatialMap;+import ghidra.util.database.spatial.rect.Abstract2DRStarTree.XAxis;+import ghidra.util.database.spatial.rect.Abstract2DRStarTree.YAxis;import ghidra.util.exception.CancelledException;import ghidra.util.exception.VersionException;import ghidra.util.task.ConsoleTaskMonitor;@@ -411,4 +416,55 @@ public class DBTraceAddressSnapRangePropertyMapSpaceTestassertEquals(ent(0x1000, 5, entry1), obj.space1.firstEntry());}++ @Test+ public void testSplitChoiceLinear() throws Exception {+ int total = DBTraceAddressSnapRangePropertyMapTree.MAX_CHILDREN + 1;++ try (Transaction tx = obj.openTransaction("Create entries")) {+ List<DBTreeRecord<?, ? extends TraceAddressSnapRange>> entries = new ArrayList<>();+ for (int i = 0; i < total; i++) {+ entries.add(+ obj.space1.put(new ImmutableTraceAddressSnapRange(addr(0x1000 + i), 5), null));+ }+ /**+ * NOTE: Because we're using MAX+1, the internal tree will already have split by this+ * time. That shouldn't matter. We must use MAX+1, because this choose-axis function+ * assumes that number of children given in the list.+ */+ Comparator<TraceAddressSnapRange> axis = obj.space1.tree.doChooseSplitAxis(entries);+ MatcherAssert.assertThat(axis, Matchers.instanceOf(XAxis.class));++ int index = obj.space1.tree.doChooseSplitIndex(entries, axis);+ assertEquals(total / 2, index);+ }+ }++ @Test+ public void testSplitChoiceTwoLines() throws Exception {+ int total = DBTraceAddressSnapRangePropertyMapTree.MAX_CHILDREN + 1;+ int cut = total / 2;++ try (Transaction tx = obj.openTransaction("Create entries")) {+ List<DBTreeRecord<?, ? extends TraceAddressSnapRange>> entries = new ArrayList<>();+ for (int i = 0; i < total / 2; i++) {+ entries.add(obj.space1+ .put(new ImmutableTraceAddressSnapRange(addr(0x1000 + i), 0), null));+ }+ for (int i = cut; i < total; i++) {+ entries.add(obj.space1+ .put(new ImmutableTraceAddressSnapRange(addr(0x1000 - cut + i), 10), null));+ }+ /**+ * NOTE: Because we're using MAX+1, the internal tree will already have split by this+ * time. That shouldn't matter. We must use MAX+1, because this choose-axis function+ * assumes that number of children given in the list.+ */+ Comparator<TraceAddressSnapRange> axis = obj.space1.tree.doChooseSplitAxis(entries);+ MatcherAssert.assertThat(axis, Matchers.instanceOf(YAxis.class));++ int index = obj.space1.tree.doChooseSplitIndex(entries, axis);+ assertEquals(cut, index);+ }+ }}diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/DBCachedObjectStoreFactory.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/DBCachedObjectStoreFactory.javaindex 179ce06a4e..6477eed825 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/DBCachedObjectStoreFactory.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/DBCachedObjectStoreFactory.java@@ -16,6 +16,7 @@package ghidra.util.database;import java.io.IOException;+import java.lang.invoke.MethodType;import java.lang.reflect.*;import java.lang.reflect.Field;import java.nio.*;@@ -41,19 +42,19 @@ import ghidra.util.exception.VersionException;* See {@link DBAnnotatedObject} for more documentation, including an example object definition. To* create a store, e.g., for {@code Person}:*- * <pre>{@code+ * <pre>* interface MyDomainObject {* Person createPerson(String name, String address);** Person getPerson(long id);*- * Collection<? extends Person> getPeopleNamed(String name);+ * Collection<? extends Person> getPeopleNamed(String name);* }** public class DBMyDomainObject extends DBCachedDomainObjectAdapter implements MyDomainObject {* private final DBCachedObjectStoreFactory factory;- * private final DBCachedObjectStore<DBPerson> people;- * private final DBCachedObjectIndex<String, DBPerson> peopleByName;+ * private final DBCachedObjectStore<DBPerson> people;+ * private final DBCachedObjectIndex<String, DBPerson> peopleByName;** public DBMyDomainObject() { // Constructor parameters elided* // super() invocation elided@@ -71,7 +72,7 @@ import ghidra.util.exception.VersionException;* }* }*- * @Override+ * @Override* public Person createPerson(String name, String address) {* // Locking details elided* DBPerson person = people.create();@@ -79,19 +80,19 @@ import ghidra.util.exception.VersionException;* return person;* }*- * @Override+ * @Override* public Person getPerson(int id) {* // Locking details elided* return people.getAt(id);* }*- * @Override- * public Collection<Person> getPeopleNamed(String name) {+ * @Override+ * public Collection<Person> getPeopleNamed(String name) {* // Locking details elided* return peopleByName.get(name);* }* }- * }</pre>+ * </pre>** <p>* The factory manages tables on behalf of the domain object, so it is typically the first thing@@ -159,7 +160,7 @@ public class DBCachedObjectStoreFactory {* {@link DBAnnotatedObject} is sufficient. If context is required, then additional interfaces* can be required via type intersection:*- * <pre>{@code+ * <pre>* public interface MyContext {* // ...* }@@ -168,21 +169,21 @@ public class DBCachedObjectStoreFactory {* MyContext getContext();* }*- * public static class MyDBFieldCodec<OT extends DBAnnotatedObject & ContextProvider> extends- * AbstractDBFieldCodec<MyType, OT, BinaryField> {+ * public static class MyDBFieldCodec<OT extends DBAnnotatedObject & ContextProvider> extends+ * AbstractDBFieldCodec<MyType, OT, BinaryField> {*- * public MyDBFieldCodec(Class<OT> objectType, Field field, int column) {+ * public MyDBFieldCodec(Class<OT> objectType, Field field, int column) {* super(MyType.class, objectType, BinaryField.class, field, column);* }*- * @Override+ * @Override* protected void doStore(OT obj, DBRecord record) {* MyContext ctx = obj.getContext();* // ...* }* // ...* }- * }</pre>+ * </pre>** <p>* Note that this implementation uses {@link AbstractDBFieldCodec}, which is highly recommended.@@ -194,25 +195,25 @@ public class DBCachedObjectStoreFactory {* {@link BinaryField}. See {@link ByteDBFieldCodec} for the simplest example with actual* encoding and decoding implementations. To use the example codec in an object:*- * <pre>{@code- * @DBAnnotatedObjectInfo(version = 1)+ * <pre>+ * @DBAnnotatedObjectInfo(version = 1)* public static class SomeObject extends DBAnnotatedObject implements ContextProvider {* static final String MY_COLUMN_NAME = "My";*- * @DBAnnotatedColumn(MY_COLUMN_NAME)+ * @DBAnnotatedColumn(MY_COLUMN_NAME)* static DBObjectColumn MY_COLUMN;*- * @DBAnnotatedField(column = MY_COLUMN_NAME, codec = MyDBFieldCodec.class)+ * @DBAnnotatedField(column = MY_COLUMN_NAME, codec = MyDBFieldCodec.class)* private MyType my;** // ...*- * @Override+ * @Override* public MyContext getContext() {* // ...* }* }- * }</pre>+ * </pre>** <p>* Notice that {@code SomeObject} must implement {@code ContextProvider}. This restriction is@@ -307,9 +308,11 @@ public class DBCachedObjectStoreFactory {* This reduces the implementation burden to {@link #doLoad(DBAnnotatedObject, DBRecord)},* {@link #doStore(DBAnnotatedObject, DBRecord)}, and {@link #store(Object, db.Field)}.*/- public static abstract class AbstractDBFieldCodec<VT, OT extends DBAnnotatedObject, FT extends db.Field>+ public static abstract class AbstractDBFieldCodec<VT, OT extends DBAnnotatedObject,+ FT extends db.Field>implements DBFieldCodec<VT, OT, FT> {protected final Class<VT> valueType;+ protected final Class<VT> boxedType;protected final Class<OT> objectType;protected final Class<FT> fieldType;protected final Field field;@@ -335,6 +338,9 @@ public class DBCachedObjectStoreFactory {"Given field does not have the given type: " + valueType + " != " + field);}this.valueType = valueType;+ @SuppressWarnings("unchecked")+ Class<VT> boxedType = (Class<VT>) MethodType.methodType(valueType).wrap().returnType();+ this.boxedType = boxedType;this.objectType = objectType;this.fieldType = fieldType;this.field = field;@@ -379,7 +385,7 @@ public class DBCachedObjectStoreFactory {@Overridepublic VT getValue(OT obj) {try {- return valueType.cast(field.get(obj));+ return boxedType.cast(field.get(obj));}catch (IllegalArgumentException | IllegalAccessException e) {throw new AssertionError(e);diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractConstraintsTree.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractConstraintsTree.javaindex ab159d8642..700034a5b9 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractConstraintsTree.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractConstraintsTree.java@@ -44,10 +44,10 @@ public abstract class AbstractConstraintsTree<protected final DBCachedObjectStore<DR> dataStore;protected final DBCachedObjectStore<NR> nodeStore;- protected final Map<Long, Collection<DR>> cachedDataChildren =- new FixedSizeHashMap<>(MAX_CACHE_ENTRIES);- protected final Map<Long, Collection<NR>> cachedNodeChildren =- new FixedSizeHashMap<>(MAX_CACHE_ENTRIES);+ protected final Map<Long, Collection<DR>> cachedDataChildren = Collections.synchronizedMap(+ new FixedSizeHashMap<>(MAX_CACHE_ENTRIES));+ protected final Map<Long, Collection<NR>> cachedNodeChildren = Collections.synchronizedMap(+ new FixedSizeHashMap<>(MAX_CACHE_ENTRIES));protected NR root;protected int leafLevel;@@ -314,7 +314,10 @@ public abstract class AbstractConstraintsTree<}private void descend(NR nr) {- queue.addAll(getChildrenOf(nr));+ List<? extends DBTreeRecord<?, ? extends NS>> passed = getChildrenOf(nr).stream()+ .filter(c -> query.testNode(c.getBounds()) != QueryInclusion.NONE)+ .toList();+ queue.addAll(passed);}private DR findNext() {@@ -323,9 +326,6 @@ public abstract class AbstractConstraintsTree<if (rec == null) {return null;}- if (query != null && query.terminateEarlyNode(rec.getBounds())) {- return null;- }if (rec instanceof DBTreeDataRecord) {@SuppressWarnings("unchecked")DR dr = (DR) rec;@@ -337,9 +337,7 @@ public abstract class AbstractConstraintsTree<assert rec instanceof DBTreeNodeRecord;@SuppressWarnings("unchecked")NR nr = (NR) rec;- if (query != null && query.testNode(nr.getShape()) != QueryInclusion.NONE) {- descend(nr);- }+ descend(nr);continue;}}@@ -562,7 +560,7 @@ public abstract class AbstractConstraintsTree<protected void doRecomputeBounds(NR node) {/*- * TODO: There may be optimizations here, esp. if no bound of the removed node is on the+ * LATER: There may be optimizations here, esp. if no bound of the removed node is on the* edge of the parent. Furthermore, since an implementation may index on those bounds, there* may be a fast way to discover the "next child in".*/diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractRStarConstraintsTree.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractRStarConstraintsTree.javaindex bc8d7015d6..d2180a80d8 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractRStarConstraintsTree.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/AbstractRStarConstraintsTree.java@@ -90,6 +90,35 @@ public abstract class AbstractRStarConstraintsTree<}}+ protected class LeastOverlap implements Comparable<LeastOverlap> {+ private final NR node;+ private final double areaEnlargement;+ private final double overlapEnlargement;++ public LeastOverlap(NR node, NS bounds, List<NR> all, double areaEnlargement) {+ this.node = node;+ this.areaEnlargement = areaEnlargement;++ double overlap = computeOverlap(node.getShape(), all, node);+ overlapEnlargement =+ computeOverlap(node.getShape().unionBounds(bounds), all, node) - overlap;+ }++ @Override+ public int compareTo(AbstractRStarConstraintsTree<DS, DR, NS, NR, T, Q>.LeastOverlap o) {+ int result;+ result = Double.compare(this.overlapEnlargement, o.overlapEnlargement);+ if (result != 0) {+ return result;+ }+ result = Double.compare(this.areaEnlargement, o.areaEnlargement);+ if (result != 0) {+ return result;+ }+ return 0;+ }+ }+protected class LeastDistanceFromCenterToPointimplements Comparable<LeastDistanceFromCenterToPoint> {private final DBTreeRecord<?, ? extends NS> record;@@ -140,15 +169,15 @@ public abstract class AbstractRStarConstraintsTree<NR node = root;// CS2+ /**+ * The paper recommends we only apply the nearly-minimal overlap reduction on the leaf+ * parent. I think this is just for cost savings. I get better search performance when I+ * apply it to all levels. Insertion is a little slower, though. We can explore reverting+ * this, if other tweaks work.+ */for (int i = 0; i < dstLevelFromTop; i++) {assert !node.getType().isLeaf();- if (node.getType().isLeafParent()) {- node = findChildByNearlyMinimumOverlapCost(node, bounds);- }- else {- assert node.getType().isDirectory();- node = findChildByMinimumEnlargementCost(node, bounds);- }+ node = findChildByNearlyMinimumOverlapCost(node, bounds);// CS3 (by virtue of setting node, and the while loop}return node;@@ -163,21 +192,15 @@ public abstract class AbstractRStarConstraintsTree<* @return*/protected NR findChildByMinimumEnlargementCost(NR n, NS bounds) {- assert !n.getType().isLeafParent() && n.getType().isDirectory();- NR bestChild = null;- double bestAreaEnlargement = 0;+ LeastAreaEnlargementThenLeastArea least = null;for (NR child : getNodeChildrenOf(n)) {- double candidateAreaEnlargement =- child.getShape().computeAreaUnionBounds(bounds) - child.getShape().getArea();- if (bestChild == null || candidateAreaEnlargement < bestAreaEnlargement ||- (candidateAreaEnlargement == bestAreaEnlargement &&- child.getShape().getArea() < bestChild.getShape().getArea())) {- bestChild = child;- bestAreaEnlargement = candidateAreaEnlargement;+ LeastAreaEnlargementThenLeastArea candidate =+ new LeastAreaEnlargementThenLeastArea(child, bounds);+ if (least == null || candidate.compareTo(least) < 0) {+ least = candidate;}}- assert bestChild != null;- return bestChild;+ return least.node;}/**@@ -192,7 +215,6 @@ public abstract class AbstractRStarConstraintsTree<* @return the leaf node into which the object should be inserted*/protected NR findChildByNearlyMinimumOverlapCost(NR n, NS bounds) {- assert n.getType().isLeafParent();PriorityQueue<LeastAreaEnlargementThenLeastArea> sorted =new PriorityQueue<>(n.getChildCount());List<NR> children = new ArrayList<>(getNodeChildrenOf(n));@@ -200,29 +222,20 @@ public abstract class AbstractRStarConstraintsTree<assert leaf.getType().isLeaf();sorted.offer(new LeastAreaEnlargementThenLeastArea(leaf, bounds));}- NR bestLeaf = null;- double bestOverlapEnlargement = 0;- double bestAreaEnlargement = 0;++ LeastOverlap least = null;for (int i = 0; i < CHEAT_OVERLAP_COUNT; i++) {LeastAreaEnlargementThenLeastArea measure = sorted.poll();if (measure == null) {break;}- double candidateOverlap =- computeOverlap(measure.node.getShape(), children, measure.node);- double candidateOverlapEnlargement =- computeOverlap(measure.node.getShape().unionBounds(bounds), children,- measure.node) - candidateOverlap;- if (bestLeaf == null || candidateOverlapEnlargement < bestOverlapEnlargement ||- (candidateOverlapEnlargement == bestOverlapEnlargement &&- measure.areaEnlargement < bestAreaEnlargement)) {- bestLeaf = measure.node;- bestOverlapEnlargement = candidateOverlapEnlargement;- bestAreaEnlargement = measure.areaEnlargement;+ LeastOverlap candidate =+ new LeastOverlap(measure.node, bounds, children, measure.areaEnlargement);+ if (least == null || candidate.compareTo(least) < 0) {+ least = candidate;}}- assert bestLeaf != null;- return bestLeaf;+ return least.node;}/**@@ -358,6 +371,19 @@ public abstract class AbstractRStarConstraintsTree<return bestAxis;}+ record IndexScore(int index, double overlap, double areaSum, double areaDiff)+ implements Comparable<IndexScore> {+ static final Comparator<IndexScore> COMPARATOR = Comparator+ .comparing(IndexScore::overlap)+ .thenComparing(IndexScore::areaSum)+ .thenComparing(IndexScore::areaDiff);++ @Override+ public int compareTo(IndexScore o) {+ return COMPARATOR.compare(this, o);+ }+ }+protected int doChooseSplitIndex(List<DBTreeRecord<?, ? extends NS>> children,Comparator<NS> axis) {children.sort(Comparator.comparing(DBTreeRecord::getBounds, axis));@@ -368,21 +394,20 @@ public abstract class AbstractRStarConstraintsTree<// mmm-------mmm (m = 3)// 8 distributions : 12 - 2*3 + 2+ List<DBTreeRecord<?, ? extends NS>> reversed = children.reversed();NS boundsFirstKChildren =unionStream(children.subList(0, minChildren).stream().map(DBTreeRecord::getBounds));NS boundsLastKChildren =- unionStream(children.subList(maxChildren + 1 - minChildren, maxChildren + 1)- .stream()- .map(DBTreeRecord::getBounds));+ unionStream(reversed.subList(0, minChildren).stream().map(DBTreeRecord::getBounds));int maxK = maxChildren + 1 - minChildren * 2;Deque<NS> boundsFirsts = new ArrayDeque<>();Deque<NS> boundsSeconds = new ArrayDeque<>();boundsFirsts.addLast(boundsFirstKChildren);boundsSeconds.addFirst(boundsLastKChildren);- for (int k = 0; k <= maxK; k++) {- NS forFirst = children.get(minChildren + k).getBounds();- NS forSecond = children.get(maxChildren - minChildren - k).getBounds();+ for (int k = 1; k <= maxK; k++) { // i=0 case already done+ NS forFirst = children.get(minChildren - 1 + k).getBounds();+ NS forSecond = reversed.get(minChildren - 1 + k).getBounds();boundsFirstKChildren = boundsFirstKChildren.unionBounds(forFirst);boundsLastKChildren = boundsLastKChildren.unionBounds(forSecond);@@ -392,22 +417,22 @@ public abstract class AbstractRStarConstraintsTree<}// CSI1- double bestOverlapValue = Double.MAX_VALUE;- double bestAreaValue = Double.MAX_VALUE;- int bestIndex = -1;+ IndexScore best = null;for (int k = 0; k <= maxK; k++) {NS boundsFirstGroup = boundsFirsts.removeFirst();NS boundsSecondGroup = boundsSeconds.removeFirst();- double overlapValue = boundsFirstGroup.computeAreaIntersection(boundsSecondGroup);- double areaValue = boundsFirstGroup.getArea() + boundsSecondGroup.getArea();- if (bestIndex == -1 || overlapValue < bestOverlapValue ||- (overlapValue == bestOverlapValue && areaValue < bestAreaValue)) {- bestIndex = k;- bestOverlapValue = overlapValue;+ double areaFirst = boundsFirstGroup.getArea();+ double areaSecond = boundsSecondGroup.getArea();+ IndexScore candidate = new IndexScore(k,+ boundsFirstGroup.computeAreaIntersection(boundsSecondGroup),+ areaFirst + areaSecond,+ Math.abs(areaFirst - areaSecond));++ if (best == null || candidate.compareTo(best) < 0) {+ best = candidate;}}- assert bestIndex != -1;- return bestIndex + minChildren;+ return best.index + minChildren;}protected static class ReInsertInfo {diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/BoundingShape.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/BoundingShape.javaindex 8eed8523ae..bbcd15dd56 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/BoundingShape.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/BoundingShape.java@@ -16,6 +16,7 @@package ghidra.util.database.spatial;public interface BoundingShape<S extends BoundingShape<S>> extends BoundedShape<S> {+double getArea();double getMargin();diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperBoxQuery.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperBoxQuery.javaindex 13ac4e8bd6..22ff8768e7 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperBoxQuery.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperBoxQuery.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -20,47 +20,48 @@ import java.util.Comparator;import ghidra.util.database.spatial.BoundedShape;import ghidra.util.database.spatial.Query;-public abstract class AbstractHyperBoxQuery< //- P extends HyperPoint, //- DS extends BoundedShape<NS>, //- NS extends HyperBox<P, NS>, //- Q extends AbstractHyperBoxQuery<P, DS, NS, Q>> //+public abstract class AbstractHyperBoxQuery<+ P extends HyperPoint,+ DS extends BoundedShape<NS>,+ NS extends HyperBox<P, NS>,+ Q extends AbstractHyperBoxQuery<P, DS, NS, Q>>implements Query<DS, NS> {- public interface QueryFactory<NS extends HyperBox<?, NS>, Q extends AbstractHyperBoxQuery<?, ?, NS, Q>> {+ public interface QueryFactory<NS extends HyperBox<?, NS>,+ Q extends AbstractHyperBoxQuery<?, ?, NS, Q>> {Q create(NS ls, NS us, HyperDirection direction);}- protected static <P extends HyperPoint, NS extends HyperBox<P, NS>, //- Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q intersecting(NS shape,- HyperDirection direction, QueryFactory<NS, Q> factory) {+ protected static <P extends HyperPoint, NS extends HyperBox<P, NS>,+ Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q intersecting(NS shape,+ HyperDirection direction, QueryFactory<NS, Q> factory) {HyperBox<P, ?> full = shape.space().getFull();NS ls = shape.immutable(full.lCorner(), shape.uCorner());NS us = shape.immutable(shape.lCorner(), full.uCorner());return factory.create(ls, us, direction);}- protected static <P extends HyperPoint, NS extends HyperBox<P, NS>, //- Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q enclosing(NS shape,- HyperDirection direction, QueryFactory<NS, Q> factory) {+ protected static <P extends HyperPoint, NS extends HyperBox<P, NS>,+ Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q enclosing(NS shape,+ HyperDirection direction, QueryFactory<NS, Q> factory) {HyperBox<P, ?> full = shape.space().getFull();NS ls = shape.immutable(full.lCorner(), shape.lCorner());NS us = shape.immutable(shape.uCorner(), full.uCorner());return factory.create(ls, us, direction);}- protected static <P extends HyperPoint, NS extends HyperBox<P, NS>, //- Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q enclosed(NS shape,- HyperDirection direction, QueryFactory<NS, Q> factory) {+ protected static <P extends HyperPoint, NS extends HyperBox<P, NS>,+ Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q enclosed(NS shape,+ HyperDirection direction, QueryFactory<NS, Q> factory) {HyperBox<P, ?> full = shape.space().getFull();NS ls = shape.immutable(shape.lCorner(), full.uCorner());NS us = shape.immutable(full.lCorner(), shape.uCorner());return factory.create(ls, us, direction);}- protected static <P extends HyperPoint, NS extends HyperBox<P, NS>, //- Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q equalTo(NS shape,- HyperDirection direction, QueryFactory<NS, Q> factory) {+ protected static <P extends HyperPoint, NS extends HyperBox<P, NS>,+ Q extends AbstractHyperBoxQuery<P, ?, NS, Q>> Q equalTo(NS shape,+ HyperDirection direction, QueryFactory<NS, Q> factory) {NS ls = shape.immutable(shape.lCorner(), shape.lCorner());NS us = shape.immutable(shape.uCorner(), shape.uCorner());return factory.create(ls, us, direction);diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperRStarTree.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperRStarTree.javaindex d8dfadf2e4..aea57b30d2 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperRStarTree.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/AbstractHyperRStarTree.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -23,20 +23,20 @@ import ghidra.util.database.DBCachedObjectStoreFactory;import ghidra.util.database.spatial.*;import ghidra.util.exception.VersionException;-public abstract class AbstractHyperRStarTree< //- P extends HyperPoint, //- DS extends BoundedShape<NS>, //- DR extends DBTreeDataRecord<DS, NS, T>, //- NS extends HyperBox<P, NS>, //- NR extends DBTreeNodeRecord<NS>, //- T, //- Q extends AbstractHyperBoxQuery<P, DS, NS, Q>> //+public abstract class AbstractHyperRStarTree<+ P extends HyperPoint,+ DS extends BoundedShape<NS>,+ DR extends DBTreeDataRecord<DS, NS, T>,+ NS extends HyperBox<P, NS>,+ NR extends DBTreeNodeRecord<NS>,+ T,+ Q extends AbstractHyperBoxQuery<P, DS, NS, Q>>extends AbstractRStarConstraintsTree<DS, DR, NS, NR, T, Q> {- protected static class AsSpatialMap< //- DS extends BoundedShape<NS>, //- DR extends DBTreeDataRecord<DS, NS, T>, //- NS extends HyperBox<?, NS>, T, Q extends AbstractHyperBoxQuery<?, DS, NS, Q>>+ protected static class AsSpatialMap<+ DS extends BoundedShape<NS>,+ DR extends DBTreeDataRecord<DS, NS, T>,+ NS extends HyperBox<?, NS>, T, Q extends AbstractHyperBoxQuery<?, DS, NS, Q>>extends AbstractConstraintsTreeSpatialMap<DS, DR, NS, T, Q> {public AsSpatialMap(AbstractConstraintsTree<DS, DR, NS, ?, T, Q> tree, Q query) {super(tree, query);diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/Dimension.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/Dimension.javaindex 26c2271468..a9b1218fe8 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/Dimension.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/Dimension.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -28,7 +28,7 @@ public interface Dimension<T, P extends HyperPoint, B extends HyperBox<P, B>> {int compare(T a, T b);- double distance(T a, T b);+ double distance(T upper, T lower);T mid(T a, T b);diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/LongDimension.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/LongDimension.javaindex e04cc4cd3b..16e2095c12 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/LongDimension.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/LongDimension.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -24,8 +24,8 @@ public interface LongDimension<P extends HyperPoint, B extends HyperBox<P, B>>}@Override- default double distance(Long a, Long b) {- return a - b;+ default double distance(Long upper, Long lower) {+ return upper - lower;}@Overridediff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/StringDimension.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/StringDimension.javaindex bf49232bbf..85f73a7926 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/StringDimension.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/StringDimension.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -60,19 +60,19 @@ public interface StringDimension<P extends HyperPoint, B extends HyperBox<P, B>>}@Override- default double distance(String a, String b) {- if (Objects.equals(a, b)) {+ default double distance(String upper, String lower) {+ if (Objects.equals(upper, lower)) {return 0;}// TODO: May revisit the starting place value, to scale this dimension down in importance.double result = 0;double placeVal = Double.MAX_VALUE / 128;- int len = lenStrings(a, b);+ int len = lenStrings(upper, lower);for (int i = 0; i < len; i++) {- int ca = charAt(a, i);- int cb = charAt(b, i);+ int cu = charAt(upper, i);+ int cl = charAt(lower, i);double oldResult = result;- result += placeVal * (cb - ca);+ result += placeVal * (cu - cl);if (oldResult == result) {// Can't capture any more precision, so we're donereturn result;diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/ULongDimension.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/ULongDimension.javaindex 456b966224..67d0b98af4 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/ULongDimension.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/hyper/ULongDimension.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -24,8 +24,8 @@ public interface ULongDimension<P extends HyperPoint, B extends HyperBox<P, B>>}@Override- default double distance(Long a, Long b) {- return a - b;+ default double distance(Long upper, Long lower) {+ return upper - lower;}@Overridediff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/Abstract2DRStarTree.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/Abstract2DRStarTree.javaindex bd7cb74c1c..c4be7287a5 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/Abstract2DRStarTree.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/Abstract2DRStarTree.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -23,20 +23,20 @@ import ghidra.util.database.DBCachedObjectStoreFactory;import ghidra.util.database.spatial.*;import ghidra.util.exception.VersionException;-public abstract class Abstract2DRStarTree< //- X, Y, //- DS extends BoundedShape<NS>, //- DR extends DBTreeDataRecord<DS, NS, T>, //- NS extends Rectangle2D<X, Y, NS>, //- NR extends DBTreeNodeRecord<NS>, //- T, //- Q extends AbstractRectangle2DQuery<X, Y, DS, NS, Q>> //+public abstract class Abstract2DRStarTree<+ X, Y,+ DS extends BoundedShape<NS>,+ DR extends DBTreeDataRecord<DS, NS, T>,+ NS extends Rectangle2D<X, Y, NS>,+ NR extends DBTreeNodeRecord<NS>,+ T,+ Q extends AbstractRectangle2DQuery<X, Y, DS, NS, Q>>extends AbstractRStarConstraintsTree<DS, DR, NS, NR, T, Q> {- protected static class AsSpatialMap< //- DS extends BoundedShape<NS>, //- DR extends DBTreeDataRecord<DS, NS, T>, //- NS extends Rectangle2D<?, ?, NS>, T, Q extends AbstractRectangle2DQuery<?, ?, DS, NS, Q>>+ protected static class AsSpatialMap<+ DS extends BoundedShape<NS>,+ DR extends DBTreeDataRecord<DS, NS, T>,+ NS extends Rectangle2D<?, ?, NS>, T, Q extends AbstractRectangle2DQuery<?, ?, DS, NS, Q>>extends AbstractConstraintsTreeSpatialMap<DS, DR, NS, T, Q> {public AsSpatialMap(AbstractConstraintsTree<DS, DR, NS, ?, T, Q> tree, Q query) {super(tree, query);@@ -52,23 +52,40 @@ public abstract class Abstract2DRStarTree< //protected final EuclideanSpace2D<X, Y> space;protected final List<Comparator<NS>> axes;+ // public for test access+ public static class XAxis<X, Y, NS extends Rectangle2D<X, Y, NS>> implements Comparator<NS> {+ private final EuclideanSpace2D<X, Y> space;++ public XAxis(EuclideanSpace2D<X, Y> space) {+ this.space = space;+ }++ @Override+ public int compare(NS o1, NS o2) {+ return space.compareX(o1.getX1(), o2.getX1());+ }+ }++ // public for test access+ public static class YAxis<X, Y, NS extends Rectangle2D<X, Y, NS>> implements Comparator<NS> {+ private final EuclideanSpace2D<X, Y> space;++ public YAxis(EuclideanSpace2D<X, Y> space) {+ this.space = space;+ }++ @Override+ public int compare(NS o1, NS o2) {+ return space.compareY(o1.getY1(), o2.getY1());+ }+ }+public Abstract2DRStarTree(DBCachedObjectStoreFactory storeFactory, String tableName,EuclideanSpace2D<X, Y> space, Class<DR> dataType, Class<NR> nodeType,boolean upgradable, int maxChildren) throws VersionException, IOException {super(storeFactory, tableName, dataType, nodeType, upgradable, maxChildren);this.space = space;-- this.axes = List.of(new Comparator<NS>() {- @Override- public int compare(NS o1, NS o2) {- return space.compareX(o1.getX1(), o2.getX1());- }- }, new Comparator<NS>() {- @Override- public int compare(NS o1, NS o2) {- return space.compareY(o1.getY1(), o2.getY1());- }- });+ this.axes = List.of(new XAxis<>(space), new YAxis<>(space));}@Overridediff --git a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/AbstractRectangle2DQuery.java b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/AbstractRectangle2DQuery.javaindex 324cb7df70..4d0eb39738 100644--- a/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/AbstractRectangle2DQuery.java+++ b/Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/database/spatial/rect/AbstractRectangle2DQuery.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -20,43 +20,48 @@ import java.util.Comparator;import ghidra.util.database.spatial.BoundedShape;import ghidra.util.database.spatial.Query;-public abstract class AbstractRectangle2DQuery< //- X, Y, //- DS extends BoundedShape<NS>, //- NS extends Rectangle2D<X, Y, NS>, //- Q extends AbstractRectangle2DQuery<X, Y, DS, NS, Q>> //+public abstract class AbstractRectangle2DQuery<+ X, Y,+ DS extends BoundedShape<NS>,+ NS extends Rectangle2D<X, Y, NS>,+ Q extends AbstractRectangle2DQuery<X, Y, DS, NS, Q>>implements Query<DS, NS> {- public interface QueryFactory<NS extends Rectangle2D<?, ?, NS>, Q extends AbstractRectangle2DQuery<?, ?, ?, NS, Q>> {+ public interface QueryFactory<NS extends Rectangle2D<?, ?, NS>,+ Q extends AbstractRectangle2DQuery<?, ?, ?, NS, Q>> {Q create(NS r1, NS r2, Rectangle2DDirection direction);}- protected static <X, Y, NS extends Rectangle2D<X, Y, NS>, Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q intersecting(- NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {+ protected static <X, Y, NS extends Rectangle2D<X, Y, NS>,+ Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q intersecting(+ NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {Rectangle2D<X, Y, ?> full = rect.getSpace().getFull();NS r1 = rect.immutable(full.getX1(), rect.getX2(), full.getY1(), rect.getY2());NS r2 = rect.immutable(rect.getX1(), full.getX2(), rect.getY1(), full.getY2());return factory.create(r1, r2, direction);}- protected static <X, Y, NS extends Rectangle2D<X, Y, NS>, Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q enclosing(- NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {+ protected static <X, Y, NS extends Rectangle2D<X, Y, NS>,+ Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q enclosing(+ NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {Rectangle2D<X, Y, ?> full = rect.getSpace().getFull();NS r1 = rect.immutable(full.getX1(), rect.getX1(), full.getY1(), rect.getY1());NS r2 = rect.immutable(rect.getX2(), full.getX2(), rect.getY2(), full.getY2());return factory.create(r1, r2, direction);}- protected static <X, Y, NS extends Rectangle2D<X, Y, NS>, Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q enclosed(- NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {+ protected static <X, Y, NS extends Rectangle2D<X, Y, NS>,+ Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q enclosed(+ NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {Rectangle2D<X, Y, ?> full = rect.getSpace().getFull();NS r1 = rect.immutable(rect.getX1(), full.getX2(), rect.getY1(), full.getY2());NS r2 = rect.immutable(full.getX1(), rect.getX2(), full.getY1(), rect.getY2());return factory.create(r1, r2, direction);}- protected static <X, Y, NS extends Rectangle2D<X, Y, NS>, Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q equalTo(- NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {+ protected static <X, Y, NS extends Rectangle2D<X, Y, NS>,+ Q extends AbstractRectangle2DQuery<X, Y, ?, NS, Q>> Q equalTo(+ NS rect, Rectangle2DDirection direction, QueryFactory<NS, Q> factory) {NS r1 = rect.immutable(rect.getX1(), rect.getX1(), rect.getY1(), rect.getY1());NS r2 = rect.immutable(rect.getX2(), rect.getX2(), rect.getY2(), rect.getY2());return factory.create(r1, r2, direction);diff --git a/Ghidra/Debug/ProposedUtils/src/main/java/utilities/util/DbgMsgTracer.java b/Ghidra/Debug/ProposedUtils/src/main/java/utilities/util/DbgMsgTracer.javanew file mode 100644index 0000000000..6a21167865--- /dev/null+++ b/Ghidra/Debug/ProposedUtils/src/main/java/utilities/util/DbgMsgTracer.java@@ -0,0 +1,61 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package utilities.util;++import java.util.Deque;+import java.util.LinkedList;+import java.util.stream.Collectors;++import ghidra.util.Msg;++public class DbgMsgTracer {+ private static final ThreadLocal<DbgMsgTracer> INSTANCES =+ ThreadLocal.withInitial(DbgMsgTracer::new);++ private final Deque<CallRec> stack = new LinkedList<>();++ public static CallRec rec(Object obj, String name) {+ DbgMsgTracer tracer = INSTANCES.get();+ CallRec rec = new CallRec(tracer, obj, name, System.currentTimeMillis());+ tracer.stack.push(rec);+ tracer.doMsg(obj, "%d: (ENTER)".formatted(rec.start));+ return rec;+ }++ String prefixStack() {+ return stack.reversed().stream().map(CallRec::name).collect(Collectors.joining(" > "));+ }++ public static void msg(Object obj, String message) {+ INSTANCES.get().doMsg(obj, message);+ }++ private void doMsg(Object obj, String message) {+ Msg.info(obj, "%s %s".formatted(prefixStack(), message));+ }++ public record CallRec(DbgMsgTracer tracer, Object obj, String name, long start)+ implements AutoCloseable {+ @Override+ public void close() {+ long stop = System.currentTimeMillis();+ long elapsedMs = stop - start;+ tracer.doMsg(obj, "%d: (EXITED) after %f s".formatted(stop, elapsedMs / 1000.0));+ CallRec popped = tracer.stack.pop();+ assert popped == this;+ }+ }+}