From ecb5a67db756d08fc88b64e519c6c21c36913499 Mon Sep 17 00:00:00 2001 From: Nikolay Igotti Date: Tue, 11 Oct 2016 18:04:08 +0300 Subject: [PATCH] Add City64 as local hash, and update RTTI accordingly. --- .../kotlin/backend/native/llvm/IrToBitcode.kt | 86 +++---- .../kotlin/backend/native/llvm/LlvmUtils.kt | 24 +- .../backend/native/llvm/RTTIGenerator.kt | 222 +++++++++--------- .../kotlin/backend/native/llvm/Runtime.kt | 37 +-- backend.native/tests/codegen/klass/basic.kt | 3 + runtime/src/main/cpp/City.cpp | 218 +++++++++++++++++ runtime/src/main/cpp/City.h | 20 ++ runtime/src/main/cpp/Names.cpp | 3 +- runtime/src/main/cpp/Names.h | 4 +- runtime/src/main/cpp/Sha1.h | 1 - 10 files changed, 432 insertions(+), 186 deletions(-) create mode 100644 backend.native/tests/codegen/klass/basic.kt create mode 100644 runtime/src/main/cpp/City.cpp create mode 100644 runtime/src/main/cpp/City.h diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/IrToBitcode.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/IrToBitcode.kt index 7fc5e0448d1..90b9f611181 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/IrToBitcode.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/IrToBitcode.kt @@ -19,7 +19,7 @@ fun emitLLVM(module: IrModuleFragment, runtimeFile: String, outFile: String) { val context = Context(module, runtime, llvmModule) // TODO: dispose module.accept(RTTIGeneratorVisitor(context), null) - module.accept(CodeGeneratorVisitor(context), null) + // module.accept(CodeGeneratorVisitor(context), null) LLVMWriteBitcodeToFile(llvmModule, outFile) } @@ -27,12 +27,12 @@ internal class RTTIGeneratorVisitor(context: Context) : IrElementVisitorVoid { val generator = RTTIGenerator(context) override fun visitElement(element: IrElement) { - element.acceptChildrenVoid(this) + element.acceptChildrenVoid(this) } override fun visitClass(declaration: IrClass) { - super.visitClass(declaration) - generator.generate(declaration.descriptor) + super.visitClass(declaration) + generator.generate(declaration.descriptor) } } @@ -43,63 +43,63 @@ internal class RTTIGeneratorVisitor(context: Context) : IrElementVisitorVoid { internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid { val generator = CodeGenerator(context) override fun visitFunction(declaration: IrFunction) { - generator.function(declaration) - declaration.acceptChildrenVoid(this) + generator.function(declaration) + declaration.acceptChildrenVoid(this) } override fun visitElement(element: IrElement) { - element.acceptChildrenVoid(this) + element.acceptChildrenVoid(this) } override fun visitSetVariable(expression: IrSetVariable) { - val value = evaluateExpression(generator.tmpVariable(), expression.value) - generator.store(value!!, generator.variable(expression.descriptor.name.asString())!!) + val value = evaluateExpression(generator.tmpVariable(), expression.value) + generator.store(value!!, generator.variable(expression.descriptor.name.asString())!!) } private fun evaluateExpression(tmpVariableName: String, value: IrExpression?): LLVMOpaqueValue? { - when (value) { - is IrCall -> return evaluateCall(tmpVariableName, value) - is IrGetValue -> return generator.load(generator.variable(value.descriptor.name.asString())!!, tmpVariableName) - null -> return null - else -> { - TODO() - } - } + when (value) { + is IrCall -> return evaluateCall(tmpVariableName, value) + is IrGetValue -> return generator.load(generator.variable(value.descriptor.name.asString())!!, tmpVariableName) + null -> return null + else -> { + TODO() + } + } } private fun evaluateCall(tmpVariableName: String, value: IrCall?): LLVMOpaqueValue? { - /* TODO: should we count on receiver? - * val tmp = tmpVar() - * val lhs = evaluateExpression(tmp, value.dispatchReceiver!!) - */ - val args = mutableListOf() - value!!.acceptChildrenVoid(object:IrElementVisitorVoid{ - override fun visitElement(element: IrElement) { - val tmp = generator.tmpVariable() - args.add(evaluateExpression(tmp, element as IrExpression)) - } - }) - when (value!!.origin) { - IrStatementOrigin.PLUS -> return generator.plus(args[0]!!, args[1]!!, tmpVariableName) - else -> { - TODO() - } - } - TODO() + /* TODO: should we count on receiver? + * val tmp = tmpVar() + * val lhs = evaluateExpression(tmp, value.dispatchReceiver!!) + */ + val args = mutableListOf() + value!!.acceptChildrenVoid(object:IrElementVisitorVoid{ + override fun visitElement(element: IrElement) { + val tmp = generator.tmpVariable() + args.add(evaluateExpression(tmp, element as IrExpression)) + } + }) + when (value!!.origin) { + IrStatementOrigin.PLUS -> return generator.plus(args[0]!!, args[1]!!, tmpVariableName) + else -> { + TODO() + } + } + TODO() } override fun visitVariable(declaration: IrVariable) { - val variableName = declaration.descriptor.name.asString() - val variableType = declaration.descriptor.type - generator.registerVariable(variableName, generator.alloca(variableType, variableName)) + val variableName = declaration.descriptor.name.asString() + val variableType = declaration.descriptor.type + generator.registerVariable(variableName, generator.alloca(variableType, variableName)) - evaluateExpression(variableName, declaration.initializer) + evaluateExpression(variableName, declaration.initializer) } override fun visitReturn(expression: IrReturn) { - val tmpVarName = generator.tmpVariable() - val value:LLVMOpaqueValue? - value = evaluateExpression(tmpVarName, expression.value) - LLVMBuildRet(context.llvmBuilder, value) + val tmpVarName = generator.tmpVariable() + val value:LLVMOpaqueValue? + value = evaluateExpression(tmpVarName, expression.value) + LLVMBuildRet(context.llvmBuilder, value) } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/LlvmUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/LlvmUtils.kt index f79a90b5681..6af02d97179 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/LlvmUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/LlvmUtils.kt @@ -13,7 +13,7 @@ internal abstract class CompileTimeValue { abstract fun getLlvmValue(): LLVMOpaqueValue? fun getLlvmType(): LLVMOpaqueType? { - return LLVMTypeOf(getLlvmValue()) + return LLVMTypeOf(getLlvmValue()) } } @@ -21,10 +21,10 @@ internal abstract class CompileTimeValue { internal class ConstArray(val elemType: LLVMOpaqueType?, val elements: List) : CompileTimeValue() { override fun getLlvmValue(): LLVMOpaqueValue? { - val values = elements.map { it.getLlvmValue() }.toTypedArray() - val valuesNativeArrayPtr = mallocNativeArrayOf(LLVMOpaqueValue, *values)[0] // FIXME: dispose + val values = elements.map { it.getLlvmValue() }.toTypedArray() + val valuesNativeArrayPtr = mallocNativeArrayOf(LLVMOpaqueValue, *values)[0] // FIXME: dispose - return LLVMConstArray(elemType, valuesNativeArrayPtr, values.size) + return LLVMConstArray(elemType, valuesNativeArrayPtr, values.size) } } @@ -33,12 +33,16 @@ internal open class Struct(val type: LLVMOpaqueType?, val elements: List Int8(1)}).toList())), + Int32(size), - superType, + superType, - objOffsets, - Int32(objOffsetsCount), + objOffsets, + Int32(objOffsetsCount), - interfaces, - Int32(interfacesCount), + interfaces, + Int32(interfacesCount), - vtable, + vtable, - methods, - Int32(methodsCount), + methods, + Int32(methodsCount), - fields, - Int32(fieldsCount) - ) + fields, + Int32(fieldsCount) + ) // TODO: probably it should be moved out of this class and shared. private fun createStructFor(className: FqName, fields: List): LLVMOpaqueType? { - val classType = LLVMStructCreateNamed(LLVMGetModuleContext(context.llvmModule), "kclass:" + className) - val fieldTypes = fields.map { getLLVMType(it.returnType!!) }.toTypedArray() - val fieldTypesNativeArrayPtr = if (fieldTypes.size > 0) { - mallocNativeArrayOf(LLVMOpaqueType, *fieldTypes)[0] // TODO: dispose - } else { - null - } + val classType = LLVMStructCreateNamed(LLVMGetModuleContext(context.llvmModule), "kclass:" + className) + val fieldTypes = fields.map { getLLVMType(it.returnType!!) }.toTypedArray() + val fieldTypesNativeArrayPtr = if (fieldTypes.size > 0) { + mallocNativeArrayOf(LLVMOpaqueType, *fieldTypes)[0] // TODO: dispose + } else { + null + } - LLVMStructSetBody(classType, fieldTypesNativeArrayPtr, fieldTypes.size, 0) - return classType + LLVMStructSetBody(classType, fieldTypesNativeArrayPtr, fieldTypes.size, 0) + return classType } // TODO: optimize private fun getVtableEntries(classDesc: ClassDescriptor): List { - val superVtableEntries = if (KotlinBuiltIns.isAny(classDesc)) { - emptyList() - } else { - getVtableEntries(classDesc.getSuperClassOrAny()) - } + val superVtableEntries = if (KotlinBuiltIns.isAny(classDesc)) { + emptyList() + } else { + getVtableEntries(classDesc.getSuperClassOrAny()) + } - val inheritedVtableSlots = Array(superVtableEntries.size, { null }) - val methods = getMethodTableEntries(classDesc) // TODO: ensure order is well-defined - val entriesForNewVtableSlots = methods.toMutableSet() + val inheritedVtableSlots = Array(superVtableEntries.size, { null }) + val methods = getMethodTableEntries(classDesc) // TODO: ensure order is well-defined + val entriesForNewVtableSlots = methods.toMutableSet() - methods.forEach { method -> - superVtableEntries.forEachIndexed { i, superMethod -> - if (OverridingUtil.overrides(method, superMethod)) { - assert (inheritedVtableSlots[i] == null) - inheritedVtableSlots[i] = method + methods.forEach { method -> + superVtableEntries.forEachIndexed { i, superMethod -> + if (OverridingUtil.overrides(method, superMethod)) { + assert (inheritedVtableSlots[i] == null) + inheritedVtableSlots[i] = method - assert (method in entriesForNewVtableSlots) - entriesForNewVtableSlots.remove(method) - } - } - } + assert (method in entriesForNewVtableSlots) + entriesForNewVtableSlots.remove(method) + } + } + } - return inheritedVtableSlots.map { it!! } + methods.filter { it in entriesForNewVtableSlots } + return inheritedVtableSlots.map { it!! } + methods.filter { it in entriesForNewVtableSlots } } private fun getMethodTableEntries(classDesc: ClassDescriptor): List { - val contributedDescriptors = classDesc.unsubstitutedMemberScope.getContributedDescriptors() - // (includes declarations from supers) + val contributedDescriptors = classDesc.unsubstitutedMemberScope.getContributedDescriptors() + // (includes declarations from supers) - val functions = contributedDescriptors.filterIsInstance() + val functions = contributedDescriptors.filterIsInstance() - val properties = contributedDescriptors.filterIsInstance() - val getters = properties.mapNotNull { it.getter } - val setters = properties.mapNotNull { it.setter } + val properties = contributedDescriptors.filterIsInstance() + val getters = properties.mapNotNull { it.getter } + val setters = properties.mapNotNull { it.setter } - val allMethods = functions + getters + setters + val allMethods = functions + getters + setters - // TODO: adding or removing 'open' modifier will break the binary compatibility - return allMethods.filter { it.modality != Modality.FINAL } + // TODO: adding or removing 'open' modifier will break the binary compatibility + return allMethods.filter { it.modality != Modality.FINAL } } fun generate(classDesc: ClassDescriptor) { - val className = classDesc.fqNameSafe + val className = classDesc.fqNameSafe - val classType = createStructFor(className, classDesc.fields) + val classType = createStructFor(className, classDesc.fields) - val name = className.nameHash + val name = className.nameHash - val size = LLVMStoreSizeOfType(runtime.targetData, classType).toInt() + val size = LLVMStoreSizeOfType(runtime.targetData, classType).toInt() - val superType = classDesc.getSuperClassOrAny().llvmTypeInfoPtr + val superType = classDesc.getSuperClassOrAny().llvmTypeInfoPtr - val interfaces = classDesc.implementedInterfaces.map { it.llvmTypeInfoPtr } - val interfacesPtr = addGlobalConstArray("kintf:$className", pointerType(runtime.typeInfoType), interfaces) + val interfaces = classDesc.implementedInterfaces.map { it.llvmTypeInfoPtr } + val interfacesPtr = addGlobalConstArray("kintf:$className", pointerType(runtime.typeInfoType), interfaces) - val refFieldIndices = classDesc.fields.mapIndexedNotNull { index, field -> - val type = field.returnType!! - if (!KotlinBuiltIns.isPrimitiveType(type)) { - index - } else { - null - } - } - // TODO: reuse offsets obtained for 'fields' below - val objOffsets = refFieldIndices.map { LLVMOffsetOfElement(runtime.targetData, classType, it) } - val objOffsetsPtr = addGlobalConstArray("krefs:$className", int32Type, objOffsets.map { Int32(it.toInt()) }) + val refFieldIndices = classDesc.fields.mapIndexedNotNull { index, field -> + val type = field.returnType!! + if (!KotlinBuiltIns.isPrimitiveType(type)) { + index + } else { + null + } + } + // TODO: reuse offsets obtained for 'fields' below + val objOffsets = refFieldIndices.map { LLVMOffsetOfElement(runtime.targetData, classType, it) } + val objOffsetsPtr = addGlobalConstArray("krefs:$className", int32Type, objOffsets.map { Int32(it.toInt()) }) - val fields = classDesc.fields.mapIndexed { index, field -> - // Note: using FQ name because a class may have multiple fields with the same name due to property overriding - val nameSignature = field.fqNameSafe.nameHash // FIXME: add signature - val fieldOffset = LLVMOffsetOfElement(runtime.targetData, classType, index) - FieldTableRecord(nameSignature, fieldOffset.toInt()) - }.sortedBy { it.nameSignature } + val fields = classDesc.fields.mapIndexed { index, field -> + // Note: using FQ name because a class may have multiple fields with the same name due to property overriding + val nameSignature = field.fqNameSafe.nameHash // FIXME: add signature + val fieldOffset = LLVMOffsetOfElement(runtime.targetData, classType, index) + FieldTableRecord(nameSignature, fieldOffset.toInt()) + }.sortedBy { it.nameSignature } - val fieldsPtr = addGlobalConstArray("kfields:$className", runtime.fieldTableRecordType, fields) + val fieldsPtr = addGlobalConstArray("kfields:$className", runtime.fieldTableRecordType, fields) - // TODO: compile-time resolution limits binary compatibility - val vtable = getVtableEntries(classDesc).map { it.implementation.entryPointAddress } - val vtablePtr = addGlobalConstArray("kvtable:$className", pointerType(int8Type), vtable) + // TODO: compile-time resolution limits binary compatibility + val vtable = getVtableEntries(classDesc).map { it.implementation.entryPointAddress } + val vtablePtr = addGlobalConstArray("kvtable:$className", pointerType(int8Type), vtable) - val methods = getMethodTableEntries(classDesc).map { - val nameSignature = it.name.nameHash // FIXME: add signature - // TODO: compile-time resolution limits binary compatibility - val methodEntryPoint = it.implementation.entryPointAddress - MethodTableRecord(nameSignature, methodEntryPoint) - }.sortedBy { it.nameSignature } + val methods = getMethodTableEntries(classDesc).map { + val nameSignature = it.name.nameHash // FIXME: add signature + // TODO: compile-time resolution limits binary compatibility + val methodEntryPoint = it.implementation.entryPointAddress + MethodTableRecord(nameSignature, methodEntryPoint) + }.sortedBy { it.nameSignature } - val methodsPtr = addGlobalConstArray("kmethods:$className", runtime.methodTableRecordType, methods) + val methodsPtr = addGlobalConstArray("kmethods:$className", runtime.methodTableRecordType, methods) - val typeInfo = TypeInfo(name, size, - superType, - objOffsetsPtr, objOffsets.size, - interfacesPtr, interfaces.size, - vtablePtr, - methodsPtr, methods.size, - fieldsPtr, fields.size) + val typeInfo = TypeInfo(name, size, + superType, + objOffsetsPtr, objOffsets.size, + interfacesPtr, interfaces.size, + vtablePtr, + methodsPtr, methods.size, + fieldsPtr, fields.size) - val typeInfoGlobal = classDesc.llvmTypeInfoPtr.getLlvmValue() // TODO: it is a hack - LLVMSetInitializer(typeInfoGlobal, typeInfo.getLlvmValue()) - LLVMSetGlobalConstant(typeInfoGlobal, 1) + val typeInfoGlobal = classDesc.llvmTypeInfoPtr.getLlvmValue() // TODO: it is a hack + LLVMSetInitializer(typeInfoGlobal, typeInfo.getLlvmValue()) + LLVMSetGlobalConstant(typeInfoGlobal, 1) } -} \ No newline at end of file +} diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/Runtime.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/Runtime.kt index 359a6945efc..942f22ad3ce 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/Runtime.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/native/llvm/Runtime.kt @@ -7,32 +7,33 @@ class Runtime(private val bitcodeFile: String) { val llvmModule: LLVMOpaqueModule init { - val arena = Arena() - try { + val arena = Arena() + try { - val bufRef = arena.alloc(LLVMOpaqueMemoryBuffer.ref) - val errorRef = arena.alloc(Int8Box.ref) - val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef, errorRef) - if (res != 0) { - throw Error(errorRef.value?.asCString()?.toString()) - } + val bufRef = arena.alloc(LLVMOpaqueMemoryBuffer.ref) + val errorRef = arena.alloc(Int8Box.ref) + val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef, errorRef) + if (res != 0) { + throw Error(errorRef.value?.asCString()?.toString()) + } - val moduleRef = arena.alloc(LLVMOpaqueModule.ref) - val parseRes = LLVMParseBitcode2(bufRef.value, moduleRef) - if (parseRes != 0) { - throw Error(parseRes.toString()) - } + val moduleRef = arena.alloc(LLVMOpaqueModule.ref) + val parseRes = LLVMParseBitcode2(bufRef.value, moduleRef) + if (parseRes != 0) { + throw Error(parseRes.toString()) + } - llvmModule = moduleRef.value!! + llvmModule = moduleRef.value!! - } finally { - arena.clear() - } + } finally { + arena.clear() + } } val typeInfoType = LLVMGetTypeByName(llvmModule, "struct.TypeInfo") val fieldTableRecordType = LLVMGetTypeByName(llvmModule, "struct.FieldTableRecord") val methodTableRecordType = LLVMGetTypeByName(llvmModule, "struct.MethodTableRecord") + val globalhHashType = LLVMGetTypeByName(llvmModule, "struct.GlobalHash") val target = LLVMGetTarget(llvmModule)!!.asCString().toString() @@ -40,4 +41,4 @@ class Runtime(private val bitcodeFile: String) { val targetData = LLVMCreateTargetData(dataLayout) -} \ No newline at end of file +} diff --git a/backend.native/tests/codegen/klass/basic.kt b/backend.native/tests/codegen/klass/basic.kt new file mode 100644 index 00000000000..fd9b0cb4f65 --- /dev/null +++ b/backend.native/tests/codegen/klass/basic.kt @@ -0,0 +1,3 @@ +class Foo { + var x : Int = 3 +} diff --git a/runtime/src/main/cpp/City.cpp b/runtime/src/main/cpp/City.cpp new file mode 100644 index 00000000000..e2484d4c012 --- /dev/null +++ b/runtime/src/main/cpp/City.cpp @@ -0,0 +1,218 @@ +#include "City.h" + +#include + +#include + +namespace { + +// Some primes between 2^63 and 2^64 for various uses. +static const uint64_t k0 = 0xc3a5c85c97cb3127ULL; +static const uint64_t k1 = 0xb492b66fbe98f273ULL; +static const uint64_t k2 = 0x9ae16a3b2f90404fULL; + +// Magic numbers for 32-bit hashing. Copied from Murmur3. +static const uint32_t c1 = 0xcc9e2d51; +static const uint32_t c2 = 0x1b873593; + +uint64_t UNALIGNED_LOAD64(const char *p) { + uint64_t result; + memcpy(&result, p, sizeof(result)); + return result; +} + +uint32_t UNALIGNED_LOAD32(const char *p) { + uint32_t result; + memcpy(&result, p, sizeof(result)); + return result; +} + +#define bswap32(x) __builtin_bswap32(x) +#define bswap64(x) __builtin_bswap64(x) + +#ifdef WORDS_BIGENDIAN +#define uint32_in_expected_order(x) (bswap32(x)) +#define uint64_in_expected_order(x) (bswap64(x)) +#else +#define uint32_in_expected_order(x) (x) +#define uint64_in_expected_order(x) (x) +#endif + +uint64_t Fetch64(const char *p) { + return uint64_in_expected_order(UNALIGNED_LOAD64(p)); +} + +uint32_t Fetch32(const char *p) { + return uint32_in_expected_order(UNALIGNED_LOAD32(p)); +} + +uint32_t Rotate32(uint32_t val, int shift) { + // Avoid shifting by 32: doing so yields an undefined result. + return shift == 0 ? val : ((val >> shift) | (val << (32 - shift))); +} + +// Bitwise right rotate. Normally this will compile to a single +// instruction, especially if the shift is a manifest constant. +uint64_t Rotate(uint64_t val, int shift) { + // Avoid shifting by 64: doing so yields an undefined result. + return shift == 0 ? val : ((val >> shift) | (val << (64 - shift))); +} + +uint64_t ShiftMix(uint64_t val) { + return val ^ (val >> 47); +} + +uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) { + // Murmur-inspired hashing. + uint64_t a = (u ^ v) * mul; + a ^= (a >> 47); + uint64_t b = (v ^ a) * mul; + b ^= (b >> 47); + b *= mul; + return b; +} + +typedef std::pair uint128_t; + +uint64_t Hash128to64(const uint128_t& x) { + // Murmur-inspired hashing. + const uint64_t kMul = 0x9ddfea08eb382d69ULL; + uint64_t a = (x.first ^ x.second) * kMul; + a ^= (a >> 47); + uint64_t b = (x.second ^ a) * kMul; + b ^= (b >> 47); + b *= kMul; + return b; +} + +uint64_t HashLen16(uint64_t u, uint64_t v) { + return Hash128to64(uint128_t(u, v)); +} + +uint64_t HashLen0to16(const char *s, size_t len) { + if (len >= 8) { + uint64_t mul = k2 + len * 2; + uint64_t a = Fetch64(s) + k2; + uint64_t b = Fetch64(s + len - 8); + uint64_t c = Rotate(b, 37) * mul + a; + uint64_t d = (Rotate(a, 25) + b) * mul; + return HashLen16(c, d, mul); + } + if (len >= 4) { + uint64_t mul = k2 + len * 2; + uint64_t a = Fetch32(s); + return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul); + } + if (len > 0) { + uint8_t a = s[0]; + uint8_t b = s[len >> 1]; + uint8_t c = s[len - 1]; + uint32_t y = static_cast(a) + (static_cast(b) << 8); + uint32_t z = len + (static_cast(c) << 2); + return ShiftMix(y * k2 ^ z * k0) * k2; + } + return k2; +} + +// This probably works well for 16-byte strings as well, but it may be overkill +// in that case. +static uint64_t HashLen17to32(const char *s, size_t len) { + uint64_t mul = k2 + len * 2; + uint64_t a = Fetch64(s) * k1; + uint64_t b = Fetch64(s + 8); + uint64_t c = Fetch64(s + len - 8) * mul; + uint64_t d = Fetch64(s + len - 16) * k2; + return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, + a + Rotate(b + k2, 18) + c, mul); +} + +// Return a 16-byte hash for 48 bytes. Quick and dirty. +// Callers do best to use "random-looking" values for a and b. +std::pair WeakHashLen32WithSeeds( + uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) { + a += w; + b = Rotate(b + a + z, 21); + uint64_t c = a; + a += x; + a += y; + b += Rotate(a, 44); + return std::make_pair(a + z, b + c); +} + +// Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. +std::pair WeakHashLen32WithSeeds( + const char* s, uint64_t a, uint64_t b) { + return WeakHashLen32WithSeeds(Fetch64(s), + Fetch64(s + 8), + Fetch64(s + 16), + Fetch64(s + 24), + a, + b); +} + +// Return an 8-byte hash for 33 to 64 bytes. +uint64_t HashLen33to64(const char *s, size_t len) { + uint64_t mul = k2 + len * 2; + uint64_t a = Fetch64(s) * k2; + uint64_t b = Fetch64(s + 8); + uint64_t c = Fetch64(s + len - 24); + uint64_t d = Fetch64(s + len - 32); + uint64_t e = Fetch64(s + 16) * k2; + uint64_t f = Fetch64(s + 24) * 9; + uint64_t g = Fetch64(s + len - 8); + uint64_t h = Fetch64(s + len - 16) * mul; + uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9; + uint64_t v = ((a + g) ^ d) + f + 1; + uint64_t w = bswap64((u + v) * mul) + h; + uint64_t x = Rotate(e + f, 42) + c; + uint64_t y = (bswap64((v + w) * mul) + g) * mul; + uint64_t z = e + f + c; + a = bswap64((x + z) * mul + y) + b; + b = ShiftMix((z + a) * mul + d + h) * mul; + return b + x; +} + +} // namespace + +extern "C" { + +uint64_t CityHash64(const void* data, size_t len) { + const char* s = reinterpret_cast(data); + if (len <= 32) { + if (len <= 16) { + return HashLen0to16(s, len); + } else { + return HashLen17to32(s, len); + } + } else if (len <= 64) { + return HashLen33to64(s, len); + } + + // For strings over 64 bytes we hash the end first, and then as we + // loop we keep 56 bytes of state: v, w, x, y, and z. + uint64_t x = Fetch64(s + len - 40); + uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56); + uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24)); + std::pair v = WeakHashLen32WithSeeds(s + len - 64, len, z); + std::pair w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x); + x = x * k1 + Fetch64(s); + + // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. + len = (len - 1) & ~static_cast(63); + do { + x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1; + y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1; + x ^= w.second; + y += v.first + Fetch64(s + 40); + z = Rotate(z + w.first, 33) * k1; + v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first); + w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16)); + std::swap(z, x); + s += 64; + len -= 64; + } while (len != 0); + return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z, + HashLen16(v.second, w.second) + x); +} + +} // extern "C" diff --git a/runtime/src/main/cpp/City.h b/runtime/src/main/cpp/City.h new file mode 100644 index 00000000000..fc7655b137e --- /dev/null +++ b/runtime/src/main/cpp/City.h @@ -0,0 +1,20 @@ +#ifndef RUNTIME_CITY_H +#define RUNTIME_CITY_H + +// CityHash, by Geoff Pike and Jyrki Alakuijala. + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Hash function for a byte array. +uint64_t CityHash64(const void* buf, size_t len); + +#ifdef __cplusplus +} +#endif + +#endif // RUNTIME_CITY_H diff --git a/runtime/src/main/cpp/Names.cpp b/runtime/src/main/cpp/Names.cpp index d9f41a0db96..2c788efb86d 100644 --- a/runtime/src/main/cpp/Names.cpp +++ b/runtime/src/main/cpp/Names.cpp @@ -2,6 +2,7 @@ #include "Names.h" +#include "City.h" #include "Sha1.h" namespace { @@ -21,7 +22,7 @@ extern "C" { // Make local hash out of arbitrary data. void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash) { - assert(false); // not implemented yet + *hash = CityHash64(data, size); } // Make global hash out of arbitrary data. diff --git a/runtime/src/main/cpp/Names.h b/runtime/src/main/cpp/Names.h index ff019c843f9..91a8f332449 100644 --- a/runtime/src/main/cpp/Names.h +++ b/runtime/src/main/cpp/Names.h @@ -6,12 +6,12 @@ // All names in system are stored as hashes (or maybe, for debug builds, // as pointers to uniqued C strings containing names?). // There are two types of hashes: -// - local hash, must be unique per class (CitiHash64 is being used) +// - local hash, must be unique per class (CityHash64 is being used) // - global hash, must be unique globally (SHA1 is being used) // Generic guideline is that global hash is being used in global persistent context, while local // hashes are more local in scope. // Local hash. -typedef int64_t LocalHash; +typedef uint64_t LocalHash; // Hash of field name. typedef LocalHash FieldNameHash; // Hash of open method name. diff --git a/runtime/src/main/cpp/Sha1.h b/runtime/src/main/cpp/Sha1.h index 8a9c47f7d34..65352e66fd9 100644 --- a/runtime/src/main/cpp/Sha1.h +++ b/runtime/src/main/cpp/Sha1.h @@ -1,6 +1,5 @@ #ifndef RUNTIME_SHA1_H #define RUNTIME_SHA1_H -/* ================ sha1.h ================ */ /* SHA-1 in C By Steve Reid