Java:HashMap性能与数百万项相比，如果需要搜索数值范围
如果可以的话，我想听听你的建议。我在我的PlayStation emulator中有一个方法（基于Java的大学论文，该论文已经完成）。它接受一个整数内存地址，然后返回该地址的字节-根据地址将读取重定向到RAM、BIOS ROM、给定的I/O端口等。目前，这是使用大量if-else案例实现的，这些案例检查地址的范围，并相应地从正确的位置读取，返回字节 这给了我大约9%的运行时间的性能冲击。我想我可以使用一个调度表来改进这一点——本质上是一个HashMap，它具有表示内存地址的自动装箱整数键和一个lambda值，用于根据地址处理字节返回。现在记住，考虑到PS1的内存映射，大约有260万个不同的可能地址，这将使用更多的内存-很好 让我困惑的是，它的性能比if-else语句的性能稍差，大约占整个运行时的12%。有没有更好的方法来做我正在做的事情？我不能使用数组解决方案（地址作为原始int索引，lambda存储在该索引中），因为地址空间中存在间隙，如果没有数量级的内存使用，这是无法处理的 我很欣赏任何其他可能使这个数字下降一点的想法——我意识到Java不是一种很好的仿真语言，但我论文的一部分是证明它可以工作（它确实可以）。非常感谢 问候,， 菲尔 编辑： 下面是readByte方法的完整代码（地址被转换为long，以允许在正常int值为负值时比较较低地址和较高地址）：Java:HashMap性能与数百万项相比，如果需要搜索数值范围,java,performance,hashmap,emulation,dispatch-table,Java,Performance,Hashmap,Emulation,Dispatch Table,如果可以的话，我想听听你的建议。我在我的PlayStation emulator中有一个方法（基于Java的大学论文，该论文已经完成）。它接受一个整数内存地址，然后返回该地址的字节-根据地址将读取重定向到RAM、BIOS ROM、给定的I/O端口等。目前，这是使用大量if-else案例实现的，这些案例检查地址的范围，并相应地从正确的位置读取，返回字节 这给了我大约9%的运行时间的性能冲击。我想我可以使用一个调度表来改进这一点——本质上是一个HashMap，它具有表示内存地址的自动装箱整数键和一个
/**
*这将根据地址从正确的区域读取。
*@param地址
*@返回
*/
公共字节读字节（整数地址）{
long tempAddress=地址&0xFFFFFFFFFFFFL；
字节retVal=0；
如果（tempAddress>=0L&&tempAddress<0x200000L）{//RAM
retVal=ram[（int）tempAddress]；
}else如果（tempAddress>=0x1F000000L&&tempAddress<0x1F800000L）{//扩展区域1
//现在什么都不要做
;
}如果（tempAddress>=0x1F800000L&&tempAddress<0x1F800400L）{//Scratchpad
//如果启用，则从数据缓存草稿行读取
如果（scratchpadEnabled（））{
tempAddress-=0x1F800000L；
retVal=scratchpad[（int）tempAddress]；
}
}else如果（tempAddress>=0x1F801000L&&tempAddress<0x1F802000L）{//I/O端口
if（tempAddress>=0x1F801000L&&tempAddress<0x1F801004L）{
int移位=（int）（tempAddress&0x3L）；
开关（换档）{
案例0：
retVal=（字节）（扩展1BaseAddress>>>24）；
打破
案例1：
retVal=（字节）（扩展1BaseAddress>>>16）；
打破
案例2：
retVal=（字节）（扩展1BaseAddress>>>8）；
打破
案例3：
retVal=（字节）扩展1BaseAddress；
打破
}
}
else if（tempAddress>=0x1F801004L&&tempAddress<0x1F801008L）{
int移位=（int）（tempAddress&0x3L）；
开关（换档）{
案例0：
retVal=（字节）（expansion2BaseAddress>>>24）；
打破
案例1：
retVal=（字节）（expansion2BaseAddress>>>16）；
打破
案例2：
retVal=（字节）（expansion2BaseAddress>>>8）；
打破
案例3：
retVal=（字节）扩展2BaseAddress；
打破
}
}else if（tempAddress>=0x1F801008L&&tempAddress<0x1F80100CL）{
int移位=（int）（tempAddress&0x3L）；
开关（换档）{
案例0：
retVal=（字节）（扩展1延迟>>>24）；
打破
案例1：
retVal=（字节）（扩展1延迟>>>16）；
打破
案例2：
retVal=（字节）（扩展1延迟>>>8）；
打破
案例3：
retVal=（字节）扩展1延迟；
打破
}
}否则如果（tempAddress>=0x1F80100CL&&tempAddress<0x1f801010）{
int移位=（int）（tempAddress&0x3L）；
开关（换档）{
案例0：
retVal=（字节）（扩展3延迟>>>24）；
打破
案例1：
retVal=（字节）（扩展3延迟>>>16）；
打破
案例2：
retVal=（字节）（扩展3延迟>>>8）；
打破
案例3：
retVal=（字节）扩展3延迟；
打破
}
}else if（tempAddress>=0x1F801010L&&tempAddress<0x1F801014L）{
int移位=（int）（tempAddress&0x3L）；
开关（换档）{
案例0：
retVal=（字节）（biosRomDelaySize>>>24）；
打破
案例1：
retVal=（字节）（biosRomDelaySize>>>16）；
打破
案例2：
retVal=（字节）（biosRomDelaySize>>>8）；
打破
案例3：
retVal=（字节）biosRomDelaySize；
打破
}
}else if（tempAddress>=0x1F801014L&&tempAddress<0x1F801018L）{
int移位=（int）（tempAddress&0x3L）；
开关（换档）
/**
* This reads from the correct area depending on the address.
* @param address
* @return
*/
public byte readByte(int address) {
long tempAddress = address & 0xFFFFFFFFL;
byte retVal = 0;
if (tempAddress >= 0L && tempAddress < 0x200000L) { // RAM
retVal = ram[(int)tempAddress];
} else if (tempAddress >= 0x1F000000L && tempAddress < 0x1F800000L) { // Expansion Region 1
// do nothing for now
;
} else if (tempAddress >= 0x1F800000L && tempAddress < 0x1F800400L) { // Scratchpad
// read from data cache scratchpad if enabled
if (scratchpadEnabled()) {
tempAddress -= 0x1F800000L;
retVal = scratchpad[(int)tempAddress];
}
} else if (tempAddress >= 0x1F801000L && tempAddress < 0x1F802000L) { // I/O Ports
if (tempAddress >= 0x1F801000L && tempAddress < 0x1F801004L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(expansion1BaseAddress >>> 24);
break;
case 1:
retVal = (byte)(expansion1BaseAddress >>> 16);
break;
case 2:
retVal = (byte)(expansion1BaseAddress >>> 8);
break;
case 3:
retVal = (byte)expansion1BaseAddress;
break;
}
}
else if (tempAddress >= 0x1F801004L && tempAddress < 0x1F801008L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(expansion2BaseAddress >>> 24);
break;
case 1:
retVal = (byte)(expansion2BaseAddress >>> 16);
break;
case 2:
retVal = (byte)(expansion2BaseAddress >>> 8);
break;
case 3:
retVal = (byte)expansion2BaseAddress;
break;
}
} else if (tempAddress >= 0x1F801008L && tempAddress < 0x1F80100CL) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(expansion1DelaySize >>> 24);
break;
case 1:
retVal = (byte)(expansion1DelaySize >>> 16);
break;
case 2:
retVal = (byte)(expansion1DelaySize >>> 8);
break;
case 3:
retVal = (byte)expansion1DelaySize;
break;
}
} else if (tempAddress >= 0x1F80100CL && tempAddress < 0x1F801010L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(expansion3DelaySize >>> 24);
break;
case 1:
retVal = (byte)(expansion3DelaySize >>> 16);
break;
case 2:
retVal = (byte)(expansion3DelaySize >>> 8);
break;
case 3:
retVal = (byte)expansion3DelaySize;
break;
}
} else if (tempAddress >= 0x1F801010L && tempAddress < 0x1F801014L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(biosRomDelaySize >>> 24);
break;
case 1:
retVal = (byte)(biosRomDelaySize >>> 16);
break;
case 2:
retVal = (byte)(biosRomDelaySize >>> 8);
break;
case 3:
retVal = (byte)biosRomDelaySize;
break;
}
} else if (tempAddress >= 0x1F801014L && tempAddress < 0x1F801018L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(spuDelaySize >>> 24);
break;
case 1:
retVal = (byte)(spuDelaySize >>> 16);
break;
case 2:
retVal = (byte)(spuDelaySize >>> 8);
break;
case 3:
retVal = (byte)spuDelaySize;
break;
}
} else if (tempAddress >= 0x1F801018L && tempAddress < 0x1F80101CL) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(cdromDelaySize >>> 24);
break;
case 1:
retVal = (byte)(cdromDelaySize >>> 16);
break;
case 2:
retVal = (byte)(cdromDelaySize >>> 8);
break;
case 3:
retVal = (byte)cdromDelaySize;
break;
}
} else if (tempAddress >= 0x1F80101CL && tempAddress < 0x1F801020L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(expansion2DelaySize >>> 24);
break;
case 1:
retVal = (byte)(expansion2DelaySize >>> 16);
break;
case 2:
retVal = (byte)(expansion2DelaySize >>> 8);
break;
case 3:
retVal = (byte)expansion2DelaySize;
break;
}
} else if (tempAddress >= 0x1F801020L && tempAddress < 0x1F801024L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(commonDelay >>> 24);
break;
case 1:
retVal = (byte)(commonDelay >>> 16);
break;
case 2:
retVal = (byte)(commonDelay >>> 8);
break;
case 3:
retVal = (byte)commonDelay;
break;
}
} else if (tempAddress >= 0x1F801040L && tempAddress < 0x1F801050L) {
// read from ControllerIO object
retVal = cio.readByte((int)tempAddress);
} else if (tempAddress >= 0x1F801060L && tempAddress < 0x1F801064L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(ramSize >>> 24);
break;
case 1:
retVal = (byte)(ramSize >>> 16);
break;
case 2:
retVal = (byte)(ramSize >>> 8);
break;
case 3:
retVal = (byte)ramSize;
break;
}
}
else if (tempAddress >= 0x1F801070L && tempAddress < 0x1F801074L) { // Interrupt Status Register
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(interruptStatusReg >>> 24);
break;
case 1:
retVal = (byte)(interruptStatusReg >>> 16);
break;
case 2:
retVal = (byte)(interruptStatusReg >>> 8);
break;
case 3:
retVal = (byte)interruptStatusReg;
break;
}
}
else if (tempAddress >= 0x1F801074L && tempAddress < 0x1F801078L) { // Interrupt Mask Register
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(interruptMaskReg >>> 24);
break;
case 1:
retVal = (byte)(interruptMaskReg >>> 16);
break;
case 2:
retVal = (byte)(interruptMaskReg >>> 8);
break;
case 3:
retVal = (byte)interruptMaskReg;
break;
}
}
else if (tempAddress >= 0x1F801080L && tempAddress < 0x1F801100L) {
retVal = dma.readByte(address);
}
else if (tempAddress >= 0x1F801100L && tempAddress < 0x1F801104L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer0.counterValueRead() >>> 24);
break;
case 1:
retVal = (byte)(timer0.counterValueRead() >>> 16);
break;
case 2:
retVal = (byte)(timer0.counterValueRead() >>> 8);
break;
case 3:
retVal = (byte)timer0.counterValueRead();
break;
}
}
else if (tempAddress >= 0x1F801104L && tempAddress < 0x1F801108L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer0.counterModeRead(false) >>> 24);
break;
case 1:
retVal = (byte)(timer0.counterModeRead(false) >>> 16);
break;
case 2:
retVal = (byte)(timer0.counterModeRead(false) >>> 8);
break;
case 3:
retVal = (byte)timer0.counterModeRead(false);
break;
}
}
else if (tempAddress >= 0x1F801108L && tempAddress < 0x1F80110CL) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer0.counterTargetRead() >>> 24);
break;
case 1:
retVal = (byte)(timer0.counterTargetRead() >>> 16);
break;
case 2:
retVal = (byte)(timer0.counterTargetRead() >>> 8);
break;
case 3:
retVal = (byte)timer0.counterTargetRead();
break;
}
}
else if (tempAddress >= 0x1F801110L && tempAddress < 0x1F801114L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer1.counterValueRead() >>> 24);
break;
case 1:
retVal = (byte)(timer1.counterValueRead() >>> 16);
break;
case 2:
retVal = (byte)(timer1.counterValueRead() >>> 8);
break;
case 3:
retVal = (byte)timer1.counterValueRead();
break;
}
}
else if (tempAddress >= 0x1F801114L && tempAddress < 0x1F801118L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer1.counterModeRead(false) >>> 24);
break;
case 1:
retVal = (byte)(timer1.counterModeRead(false) >>> 16);
break;
case 2:
retVal = (byte)(timer1.counterModeRead(false) >>> 8);
break;
case 3:
retVal = (byte)timer1.counterModeRead(false);
break;
}
}
else if (tempAddress >= 0x1F801118L && tempAddress < 0x1F80111CL) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer1.counterTargetRead() >>> 24);
break;
case 1:
retVal = (byte)(timer1.counterTargetRead() >>> 16);
break;
case 2:
retVal = (byte)(timer1.counterTargetRead() >>> 8);
break;
case 3:
retVal = (byte)timer1.counterTargetRead();
break;
}
}
else if (tempAddress >= 0x1F801120L && tempAddress < 0x1F801124L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer2.counterValueRead() >>> 24);
break;
case 1:
retVal = (byte)(timer2.counterValueRead() >>> 16);
break;
case 2:
retVal = (byte)(timer2.counterValueRead() >>> 8);
break;
case 3:
retVal = (byte)timer2.counterValueRead();
break;
}
}
else if (tempAddress >= 0x1F801124L && tempAddress < 0x1F801128L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer2.counterModeRead(false) >>> 24);
break;
case 1:
retVal = (byte)(timer2.counterModeRead(false) >>> 16);
break;
case 2:
retVal = (byte)(timer2.counterModeRead(false) >>> 8);
break;
case 3:
retVal = (byte)timer2.counterModeRead(false);
break;
}
}
else if (tempAddress >= 0x1F801128L && tempAddress < 0x1F80112CL) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(timer2.counterTargetRead() >>> 24);
break;
case 1:
retVal = (byte)(timer2.counterTargetRead() >>> 16);
break;
case 2:
retVal = (byte)(timer2.counterTargetRead() >>> 8);
break;
case 3:
retVal = (byte)timer2.counterTargetRead();
break;
}
}
else if (tempAddress >= 0x1F801810L && tempAddress < 0x1F801814L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(gpu.readResponse() >>> 24);
break;
case 1:
retVal = (byte)(gpu.readResponse() >>> 16);
break;
case 2:
retVal = (byte)(gpu.readResponse() >>> 8);
break;
case 3:
retVal = (byte)gpu.readResponse();
break;
}
}
else if (tempAddress >= 0x1F801814L && tempAddress < 0x1F801818L) {
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(gpu.readStatus() >>> 24);
break;
case 1:
retVal = (byte)(gpu.readStatus() >>> 16);
break;
case 2:
retVal = (byte)(gpu.readStatus() >>> 8);
break;
case 3:
retVal = (byte)gpu.readStatus();
break;
}
}
else if (tempAddress >= 0x1F801800L && tempAddress < 0x1F801804L) { // CDROM
switch ((int)tempAddress & 0xF) {
case 0:
retVal = cdrom.read1800();
break;
case 1:
retVal = cdrom.read1801();
break;
case 2:
retVal = cdrom.read1802();
break;
case 3:
retVal = cdrom.read1803();
break;
}
}
else if (tempAddress >= 0x1F801C00L && tempAddress < 0x1F802000L) {
// fake SPU read
retVal = spu.readByte(address);
}
} else if (tempAddress >= 0x1F802000L && tempAddress < 0x1F803000L) { // Expansion Region 2 (I/O Ports)
// read from BIOS post register
if (tempAddress == 0x1F802041L) {
retVal = biosPost;
}
} else if (tempAddress >= 0x1FA00000L && tempAddress < 0x1FC00000L) { // Expansion Region 3 (Multipurpose)
// do nothing for now
;
} else if (tempAddress >= 0x1FC00000L && tempAddress < 0x1FC80000L) { // BIOS ROM
// read from memory mapped BIOS file
tempAddress -= 0x1FC00000L;
retVal = biosBuffer.get((int)tempAddress);
} else if (tempAddress >= 0xFFFE0000L && tempAddress < 0xFFFE0200L) { // I/O Ports (Cache Control)
if (tempAddress >= 0xFFFE0130L && tempAddress < 0xFFFE0134L) { // Cache Control Register
int shift = (int)(tempAddress & 0x3L);
switch (shift) {
case 0:
retVal = (byte)(cacheControlReg >>> 24);
break;
case 1:
retVal = (byte)(cacheControlReg >>> 16);
break;
case 2:
retVal = (byte)(cacheControlReg >>> 8);
break;
case 3:
retVal = (byte)cacheControlReg;
break;
}
}
}
return retVal;
}
...
else if (tempAddress >= 0x1F801104L && tempAddress < 0x1F801108L) {
return timer0.read(tempAddress);
}
...
interface Location {
byte read(long address);
}
abstract class IntWordLocation implements Location {
@Override
final byte read(long address) {
int value = readInt(address & 0xfffffffd); // clear lower two bits;
int shift = 3 - (int) (address & 0x3);
for (int i = 0; i < shift; i++) { // replaces switch statement
value = value >>> 8;
}
return (byte) value;
}
abstract protected int readInt(long int);
}
RangeMap<Long, Location> addressRanges =
new ImmutableRangeMap.Builder<Integer, Location>()
.put(Range.closedOpen(0L, 0x200000L), ramLocation)
.put(Range.closedOpen(0x1F000000L, 0x1F800000L), NO_OP_LOCATION)
.put(Range.closedOpen(0x1F800000L, 0x1F800400L), scratchpadLocation)
// ...
.build();
public byte readByte(int address) {
return addressRanges.get(address).read(address);
}
KUSEG KSEG0 KSEG1
00000000h 80000000h A0000000h 2048K Main RAM (first 64K reserved for BIOS)
1F000000h 9F000000h BF000000h 8192K Expansion Region 1 (ROM/RAM)
1F800000h 9F800000h -- 1K Scratchpad (D-Cache used as Fast RAM)
1F801000h 9F801000h BF801000h 8K I/O Ports
1F802000h 9F802000h BF802000h 8K Expansion Region 2 (I/O Ports)
1FA00000h 9FA00000h BFA00000h 2048K Expansion Region 3 (whatever purpose)
1FC00000h 9FC00000h BFC00000h 512K BIOS ROM (Kernel) (4096K max)
FFFE0000h (KSEG2) 0.5K I/O Ports (Cache Control)
byte readMemory(int address)
{
if ((address & 0xFF000000) == 0xFF000000)
return ioPorts.read(address);
// remove most significative nibble, we don't need it
address &= 0x0FFFFFFF;
// 0xF000000 zone
// according to bios rom size you could need a different kind of comparison since it may wrap over 0xFFFFFFF
if ((address & 0xF000000) == 0xF000000)
{
// now your address space is just from 0xF000000 to 0xFC00000 + size of BIOS ROM (4mb max?)
}
else
{
// we don't know if you map bios together with ram or separately
return mainRam.readMemory(address);
}
}
F000000h
F800000h
F801000h
F802000h
FA00000h
FC00000h
address = (address >>> 12) & 0xFFF;