package com.ximple.eofms.util;
|
|
//~--- JDK imports ------------------------------------------------------------
|
|
import java.nio.ByteOrder;
|
import java.security.AccessController;
|
import java.security.PrivilegedAction;
|
|
import sun.misc.VM;
|
|
/**
|
* Bits
|
* User: Ulysses
|
* Date: 2007/6/17
|
* Time: 上午 01:16:39
|
*/
|
public class Bits
|
{
|
// -- Unsafe access --
|
// private static final Unsafe unsafe = Unsafe.getUnsafe();
|
|
// -- Processor and memory-system properties --
|
private static ByteOrder byteOrder = null;
|
private static int pageSize = -1;
|
private static boolean unaligned;
|
private static boolean unalignedKnown = false;
|
|
// -- Direct memory management --
|
// A user-settable upper limit on the maximum amount of allocatable
|
// direct buffer memory. This value may be changed during VM
|
// initialization if it is launched with "-XX:MaxDirectMemorySize=<size>".
|
private static volatile long maxMemory = VM.maxDirectMemory();
|
private static volatile long reservedMemory = 0;
|
private static boolean memoryLimitSet = false;
|
|
private Bits()
|
{
|
}
|
|
// -- Swapping --
|
public static short swap(short x)
|
{
|
return (short) ((x << 8) | ((x >> 8) & 0xff));
|
}
|
|
public static char swap(char x)
|
{
|
return (char) ((x << 8) | ((x >> 8) & 0xff));
|
}
|
|
public static int swap(int x)
|
{
|
return (int) ((swap((short) x) << 16) | (swap((short) (x >> 16)) & 0xffff));
|
}
|
|
public static long swap(long x)
|
{
|
return (long) (((long) swap((int) (x)) << 32) | ((long) swap((int) (x >> 32)) & 0xffffffffL));
|
}
|
|
// -- get/put char --
|
static private char makeChar(byte b1, byte b0)
|
{
|
return (char) ((b1 << 8) | (b0 & 0xff));
|
}
|
|
private static byte char1(char x)
|
{
|
return (byte) (x >> 8);
|
}
|
|
private static byte char0(char x)
|
{
|
return (byte) (x >> 0);
|
}
|
|
// --get/put short--
|
public static short makeShort(byte b1, byte b0)
|
{
|
return (short) ((b1 << 8) | (b0 & 0xff));
|
}
|
|
private static byte short1(short x)
|
{
|
return (byte) (x >> 8);
|
}
|
|
public static byte short0(short x)
|
{
|
return (byte) (x >> 0);
|
}
|
|
// -- get/put int --
|
public static int makeInt(byte b3, byte b2, byte b1, byte b0)
|
{
|
return (int) ((((b3 & 0xff) << 24) | ((b2 & 0xff) << 16) | ((b1 & 0xff) << 8) | ((b0 & 0xff) << 0)));
|
}
|
|
public static int makeInt(short hiword, short loword)
|
{
|
return ((hiword & 0xffff) << 16) + (loword & 0xffff);
|
}
|
|
public static short getHiShort(int qwValue)
|
{
|
return ((short) (qwValue >>> 16));
|
}
|
|
public static short getLoShort(int qwValue)
|
{
|
return ((short) (qwValue & 0xFFFF));
|
}
|
|
public static byte int3(int x)
|
{
|
return (byte) (x >> 24);
|
}
|
|
public static byte int2(int x)
|
{
|
return (byte) (x >> 16);
|
}
|
|
private static byte int1(int x)
|
{
|
return (byte) (x >> 8);
|
}
|
|
private static byte int0(int x)
|
{
|
return (byte) (x >> 0);
|
}
|
|
// -- get/put long --
|
public static long makeLong(byte b7, byte b6, byte b5, byte b4, byte b3, byte b2, byte b1, byte b0)
|
{
|
return ((((long) b7 & 0xff) << 56) | (((long) b6 & 0xff) << 48) | (((long) b5 & 0xff) << 40) | (((long) b4 & 0xff) << 32)
|
| (((long) b3 & 0xff) << 24) | (((long) b2 & 0xff) << 16) | (((long) b1 & 0xff) << 8)
|
| (((long) b0 & 0xff) << 0));
|
}
|
|
public static long makeLong(int LoValue, int HiValue)
|
{
|
return (((long) HiValue & 0xFFFFFFFF) << 32) + (((long) LoValue) & 0xFFFFFFFF);
|
}
|
|
public static int getHiInt(long qwValue)
|
{
|
return ((int) (qwValue >>> 32));
|
}
|
|
public static int getLoInt(long qwValue)
|
{
|
return ((int) (qwValue & 0xFFFFFFFF));
|
}
|
|
private static byte long7(long x)
|
{
|
return (byte) (x >> 56);
|
}
|
|
private static byte long6(long x)
|
{
|
return (byte) (x >> 48);
|
}
|
|
private static byte long5(long x)
|
{
|
return (byte) (x >> 40);
|
}
|
|
private static byte long4(long x)
|
{
|
return (byte) (x >> 32);
|
}
|
|
private static byte long3(long x)
|
{
|
return (byte) (x >> 24);
|
}
|
|
private static byte long2(long x)
|
{
|
return (byte) (x >> 16);
|
}
|
|
private static byte long1(long x)
|
{
|
return (byte) (x >> 8);
|
}
|
|
private static byte long0(long x)
|
{
|
return (byte) (x >> 0);
|
}
|
|
// -- get/put float --
|
|
// -- get/put double --
|
|
/*
|
private static byte _get(long a)
|
{
|
return unsafe.getByte(a);
|
}
|
|
private static void _put(long a, byte b)
|
{
|
unsafe.putByte(a, b);
|
}
|
|
static Unsafe unsafe()
|
{
|
return unsafe;
|
}
|
|
static ByteOrder byteOrder()
|
{
|
if (byteOrder != null)
|
{
|
return byteOrder;
|
}
|
|
long a = unsafe.allocateMemory(8);
|
|
try
|
{
|
unsafe.putLong(a, 0x0102030405060708L);
|
|
byte b = unsafe.getByte(a);
|
|
switch (b)
|
{
|
case 0x01 :
|
byteOrder = ByteOrder.BIG_ENDIAN;
|
|
break;
|
|
case 0x08 :
|
byteOrder = ByteOrder.LITTLE_ENDIAN;
|
|
break;
|
|
default :
|
throw new Error("Unknown byte order");
|
}
|
} finally
|
{
|
unsafe.freeMemory(a);
|
}
|
|
return byteOrder;
|
}
|
*/
|
|
static boolean unaligned()
|
{
|
if (unalignedKnown)
|
{
|
return unaligned;
|
}
|
|
PrivilegedAction pa = new sun.security.action.GetPropertyAction("os.arch");
|
String arch = (String) AccessController.doPrivileged(pa);
|
|
unaligned = arch.equals("i386") || arch.equals("x86");
|
unalignedKnown = true;
|
|
return unaligned;
|
}
|
|
// These methods should be called whenever direct memory is allocated or
|
// freed. They allow the user to control the amount of direct memory
|
// which a process may access. All sizes are specified in bytes.
|
static void reserveMemory(long size)
|
{
|
synchronized (Bits.class)
|
{
|
if (!memoryLimitSet && VM.isBooted())
|
{
|
maxMemory = VM.maxDirectMemory();
|
memoryLimitSet = true;
|
}
|
|
if (size <= maxMemory - reservedMemory)
|
{
|
reservedMemory += size;
|
|
return;
|
}
|
}
|
|
System.gc();
|
|
try
|
{
|
Thread.sleep(100);
|
} catch (InterruptedException x)
|
{
|
// Restore interrupt status
|
Thread.currentThread().interrupt();
|
}
|
|
synchronized (Bits.class)
|
{
|
if (reservedMemory + size > maxMemory)
|
{
|
throw new OutOfMemoryError("Direct buffer memory");
|
}
|
|
reservedMemory += size;
|
}
|
}
|
|
static synchronized void unreserveMemory(long size)
|
{
|
if (reservedMemory > 0)
|
{
|
reservedMemory -= size;
|
assert (reservedMemory > -1);
|
}
|
}
|
}
|
