mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
685 lines
29 KiB
Swift
685 lines
29 KiB
Swift
import Foundation
|
|
|
|
import UIKit
|
|
import XCTest
|
|
|
|
import Postbox
|
|
@testable import Postbox
|
|
|
|
import SwiftSignalKit
|
|
|
|
private let peerId = PeerId(namespace: 1, id: 1)
|
|
private let namespace: Int32 = 1
|
|
|
|
private extension MessageIndex {
|
|
init(id: Int32, timestamp: Int32) {
|
|
self.init(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp)
|
|
}
|
|
}
|
|
|
|
private extension MessageTags {
|
|
static let media = MessageTags(rawValue: 1 << 0)
|
|
}
|
|
|
|
class MessageHistoryIndexTableTests: XCTestCase {
|
|
var valueBox: SqliteValueBox?
|
|
var path: String?
|
|
|
|
var postbox: Postbox?
|
|
|
|
override func setUp() {
|
|
super.setUp()
|
|
|
|
self.continueAfterFailure = false
|
|
|
|
var randomId: Int64 = 0
|
|
arc4random_buf(&randomId, 8)
|
|
path = NSTemporaryDirectory() + "\(randomId)"
|
|
|
|
var randomKey = Data(count: 32)
|
|
randomKey.withUnsafeMutableBytes({ (bytes: UnsafeMutablePointer<Int8>) -> Void in
|
|
arc4random_buf(bytes, 32)
|
|
})
|
|
var randomSalt = Data(count: 16)
|
|
randomSalt.withUnsafeMutableBytes({ (bytes: UnsafeMutablePointer<Int8>) -> Void in
|
|
arc4random_buf(bytes, 16)
|
|
})
|
|
|
|
self.valueBox = SqliteValueBox(basePath: path!, queue: Queue.mainQueue(), encryptionParameters: ValueBoxEncryptionParameters(forceEncryptionIfNoSet: true, key: ValueBoxEncryptionParameters.Key(data: randomKey)!, salt: ValueBoxEncryptionParameters.Salt(data: randomSalt)!), upgradeProgress: { _ in })
|
|
|
|
let messageHoles: [PeerId.Namespace: [MessageId.Namespace: Set<MessageTags>]] = [
|
|
peerId.namespace: [
|
|
namespace: Set([.media])
|
|
]
|
|
]
|
|
|
|
let seedConfiguration = SeedConfiguration(globalMessageIdsPeerIdNamespaces: Set(), initializeChatListWithHole: (topLevel: nil, groups: nil), messageHoles: messageHoles, existingMessageTags: [.media], messageTagsWithSummary: [], existingGlobalMessageTags: [], peerNamespacesRequiringMessageTextIndex: [], peerSummaryCounterTags: { _ in PeerSummaryCounterTags(rawValue: 0) }, additionalChatListIndexNamespace: nil, messageNamespacesRequiringGroupStatsValidation: Set(), chatMessagesNamespaces: Set())
|
|
|
|
self.postbox = Postbox(queue: Queue.mainQueue(), basePath: path!, seedConfiguration: seedConfiguration, valueBox: self.valueBox!)
|
|
}
|
|
|
|
override func tearDown() {
|
|
super.tearDown()
|
|
|
|
self.postbox = nil
|
|
let _ = try? FileManager.default.removeItem(atPath: path!)
|
|
self.path = nil
|
|
}
|
|
|
|
func addHole(_ range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
|
|
var operations: [MessageHistoryIndexHoleOperationKey: [MessageHistoryIndexHoleOperation]] = [:]
|
|
self.postbox!.messageHistoryHoleIndexTable.add(peerId: peerId, namespace: namespace, space: space, range: range, operations: &operations)
|
|
}
|
|
|
|
func removeHole(_ range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
|
|
var operations: [MessageHistoryIndexHoleOperationKey: [MessageHistoryIndexHoleOperation]] = [:]
|
|
self.postbox!.messageHistoryHoleIndexTable.remove(peerId: peerId, namespace: namespace, space: space, range: range, operations: &operations)
|
|
}
|
|
|
|
func addMessage(_ id: Int32, _ timestamp: Int32, _ groupingKey: Int64? = nil) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
self.postbox!.messageHistoryIndexTable.addMessages([InternalStoreMessage(id: MessageId(peerId: peerId, namespace: namespace, id: id), timestamp: timestamp, globallyUniqueId: nil, groupingKey: groupingKey, flags: [], tags: [], globalTags: [], localTags: [], forwardInfo: nil, authorId: peerId, text: "", attributes: [], media: [])], operations: &operations)
|
|
}
|
|
|
|
func removeMessage(_ id: Int32) {
|
|
var operations: [MessageHistoryIndexOperation] = []
|
|
self.postbox!.messageHistoryIndexTable.removeMessage(MessageId(peerId: peerId, namespace: namespace, id: id), operations: &operations)
|
|
}
|
|
|
|
private func expectMessages(_ items: [MessageIndex]) {
|
|
let actualList = self.postbox!.messageHistoryIndexTable.debugList(peerId, namespace: namespace)
|
|
if items != actualList {
|
|
XCTFail("Expected\n\(items)\nGot\n\(actualList)")
|
|
}
|
|
}
|
|
|
|
private func expectHoles(space: MessageHistoryHoleSpace, _ ranges: [ClosedRange<Int32>], failure: () -> Void = {}) {
|
|
let actualList = self.postbox!.messageHistoryHoleIndexTable.debugList(peerId: peerId, namespace: namespace, space: space)
|
|
if ranges != actualList {
|
|
failure()
|
|
XCTFail("Expected\n\(ranges)\nGot\n\(actualList)")
|
|
}
|
|
}
|
|
|
|
func testEmpty() {
|
|
expectMessages([])
|
|
expectHoles(space: .everywhere, [])
|
|
expectHoles(space: .tag(.media), [])
|
|
}
|
|
|
|
func testSimpleMessages() {
|
|
addMessage(10, 10)
|
|
expectMessages([.init(id: 10, timestamp: 10)])
|
|
addMessage(11, 11)
|
|
expectMessages([.init(id: 10, timestamp: 10), .init(id: 11, timestamp: 11)])
|
|
expectHoles(space: .everywhere, [])
|
|
expectHoles(space: .tag(.media), [])
|
|
}
|
|
|
|
func testSimpleHoles() {
|
|
removeHole(1 ... Int32.max, space: .everywhere)
|
|
|
|
addHole(3 ... 10, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 10])
|
|
|
|
addHole(3 ... 10, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 10])
|
|
|
|
addHole(5 ... 20, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 20])
|
|
|
|
addHole(25 ... 30, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 20, 25 ... 30])
|
|
|
|
addHole(21 ... 23, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 23, 25 ... 30])
|
|
|
|
addHole(5 ... 25, space: .everywhere)
|
|
expectHoles(space: .everywhere, [3 ... 30])
|
|
|
|
addHole(2 ... 35, space: .everywhere)
|
|
expectHoles(space: .everywhere, [2 ... 35])
|
|
|
|
removeHole(1 ... 5, space: .everywhere)
|
|
expectHoles(space: .everywhere, [6 ... 35])
|
|
|
|
removeHole(11 ... 11, space: .everywhere)
|
|
expectHoles(space: .everywhere, [6 ... 10, 12 ... 35])
|
|
|
|
removeHole(8 ... 15, space: .everywhere)
|
|
expectHoles(space: .everywhere, [6 ... 7, 16 ... 35])
|
|
|
|
removeHole(1 ... 16, space: .everywhere)
|
|
expectHoles(space: .everywhere, [17 ... 35])
|
|
}
|
|
|
|
func testHoleVectors() {
|
|
struct Operation: Codable {
|
|
struct Key: CodingKey {
|
|
var stringValue: String
|
|
|
|
init?(stringValue: String) {
|
|
self.stringValue = stringValue
|
|
}
|
|
|
|
let intValue: Int? = nil
|
|
init?(intValue: Int) {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
let add: Bool
|
|
let range: ClosedRange<Int32>
|
|
|
|
init(add: Bool, range: ClosedRange<Int32>) {
|
|
self.add = add
|
|
self.range = range
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: Key.self)
|
|
self.add = try container.decode(Bool.self, forKey: Key(stringValue: "a")!)
|
|
self.range = (try container.decode(Int32.self, forKey: Key(stringValue: "l")!)) ... (try container.decode(Int32.self, forKey: Key(stringValue: "u")!))
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: Key.self)
|
|
try container.encode(self.add, forKey: Key(stringValue: "a")!)
|
|
try container.encode(self.range.lowerBound, forKey: Key(stringValue: "l")!)
|
|
try container.encode(self.range.upperBound, forKey: Key(stringValue: "u")!)
|
|
}
|
|
}
|
|
|
|
let bundle = Bundle(for: type(of: self))
|
|
let path = bundle.path(forResource: "HoleOperationsVector1", ofType: "json")!
|
|
let jsonData = try! Data(contentsOf: URL(fileURLWithPath: path))
|
|
|
|
var operations: [Operation] = (try? JSONDecoder().decode(Array<Operation>.self, from: jsonData)) ?? []
|
|
|
|
if operations.isEmpty {
|
|
for _ in 0 ..< 10000 {
|
|
let bound1 = Int(max(1, arc4random_uniform(1000)))
|
|
let bound2 = Int(max(1, arc4random_uniform(1000)))
|
|
let range: ClosedRange<Int> = min(bound1, bound2) ... max(bound1, bound2)
|
|
let int32Range = Int32(range.lowerBound) ... Int32(range.upperBound)
|
|
let operation = arc4random_uniform(10)
|
|
if operation < 5 {
|
|
operations.append(Operation(add: true, range: int32Range))
|
|
} else {
|
|
operations.append(Operation(add: false, range: int32Range))
|
|
}
|
|
}
|
|
let data = try! JSONEncoder().encode(operations)
|
|
print(String(data: data, encoding: .utf8)!)
|
|
}
|
|
|
|
var verificationSet = IndexSet()
|
|
for (_, holesByMessageNamespace) in self.postbox!.seedConfiguration.messageHoles {
|
|
for (_, _) in holesByMessageNamespace{
|
|
verificationSet.insert(integersIn: 1 ... Int(Int32.max - 1))
|
|
}
|
|
}
|
|
for i in 0 ..< operations.count {
|
|
let operation = operations[i]
|
|
if operation.add {
|
|
verificationSet.insert(integersIn: Int(operation.range.lowerBound) ... Int(operation.range.upperBound))
|
|
addHole(operation.range, space: .everywhere)
|
|
} else {
|
|
verificationSet.remove(integersIn: Int(operation.range.lowerBound) ... Int(operation.range.upperBound))
|
|
removeHole(operation.range, space: .everywhere)
|
|
}
|
|
let testRanges = verificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ... Int32($0.upperBound - 1)) })
|
|
expectHoles(space: .everywhere, testRanges)
|
|
expectHoles(space: .tag(.media), testRanges)
|
|
}
|
|
}
|
|
|
|
func testHoleTagVectors() {
|
|
struct Operation: Codable {
|
|
struct Key: CodingKey {
|
|
var stringValue: String
|
|
|
|
init?(stringValue: String) {
|
|
self.stringValue = stringValue
|
|
}
|
|
|
|
let intValue: Int? = nil
|
|
init?(intValue: Int) {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
let add: Bool
|
|
let range: ClosedRange<Int32>
|
|
let space: MessageHistoryHoleSpace
|
|
|
|
init(add: Bool, range: ClosedRange<Int32>, space: MessageHistoryHoleSpace) {
|
|
self.add = add
|
|
self.range = range
|
|
self.space = space
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: Key.self)
|
|
self.add = try container.decode(Bool.self, forKey: Key(stringValue: "a")!)
|
|
self.range = (try container.decode(Int32.self, forKey: Key(stringValue: "l")!)) ... (try container.decode(Int32.self, forKey: Key(stringValue: "u")!))
|
|
let spaceValue = try container.decode(Int32.self, forKey: Key(stringValue: "s")!)
|
|
if spaceValue == 0 {
|
|
self.space = .everywhere
|
|
} else {
|
|
self.space = .tag(MessageTags(rawValue: UInt32(spaceValue)))
|
|
}
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: Key.self)
|
|
try container.encode(self.add, forKey: Key(stringValue: "a")!)
|
|
try container.encode(self.range.lowerBound, forKey: Key(stringValue: "l")!)
|
|
try container.encode(self.range.upperBound, forKey: Key(stringValue: "u")!)
|
|
switch self.space {
|
|
case .everywhere:
|
|
try container.encode(0, forKey: Key(stringValue: "s")!)
|
|
case let .tag(tag):
|
|
try container.encode(Int32(tag.rawValue), forKey: Key(stringValue: "s")!)
|
|
}
|
|
}
|
|
}
|
|
|
|
var operations: [Operation] = []
|
|
let bundle = Bundle(for: type(of: self))
|
|
if let path = bundle.path(forResource: "HoleOperationsVector2", ofType: "json"), let jsonData = try? Data(contentsOf: URL(fileURLWithPath: path)) {
|
|
if let value = try? JSONDecoder().decode(Array<Operation>.self, from: jsonData) {
|
|
operations = value
|
|
}
|
|
}
|
|
|
|
if operations.isEmpty {
|
|
for _ in 0 ..< 10000 {
|
|
let bound1 = Int(max(1, arc4random_uniform(1000)))
|
|
let bound2 = Int(max(1, arc4random_uniform(1000)))
|
|
let range: ClosedRange<Int> = min(bound1, bound2) ... max(bound1, bound2)
|
|
let int32Range = Int32(range.lowerBound) ... Int32(range.upperBound)
|
|
let operation = arc4random_uniform(10)
|
|
let spaceValue = arc4random_uniform(2)
|
|
let space: MessageHistoryHoleSpace
|
|
if spaceValue == 0 {
|
|
space = .everywhere
|
|
} else {
|
|
space = .tag(.media)
|
|
}
|
|
if operation < 5 {
|
|
operations.append(Operation(add: true, range: int32Range, space: space))
|
|
} else {
|
|
operations.append(Operation(add: false, range: int32Range, space: space))
|
|
}
|
|
}
|
|
let data = try! JSONEncoder().encode(operations)
|
|
print(String(data: data, encoding: .utf8)!)
|
|
}
|
|
|
|
var everywhereVerificationSet = IndexSet()
|
|
var mediaVerificationSet = IndexSet()
|
|
for (_, holesByMessageNamespace) in self.postbox!.seedConfiguration.messageHoles {
|
|
for (_, _) in holesByMessageNamespace{
|
|
everywhereVerificationSet.insert(integersIn: 1 ... Int(Int32.max - 1))
|
|
mediaVerificationSet.insert(integersIn: 1 ... Int(Int32.max - 1))
|
|
}
|
|
}
|
|
for i in 0 ..< operations.count {
|
|
let operation = operations[i]
|
|
let intRange = Int(operation.range.lowerBound) ... Int(operation.range.upperBound)
|
|
if operation.add {
|
|
switch operation.space {
|
|
case .everywhere:
|
|
everywhereVerificationSet.insert(integersIn: intRange)
|
|
mediaVerificationSet.insert(integersIn: intRange)
|
|
case .tag:
|
|
mediaVerificationSet.insert(integersIn: intRange)
|
|
}
|
|
addHole(operation.range, space: operation.space)
|
|
} else {
|
|
switch operation.space {
|
|
case .everywhere:
|
|
everywhereVerificationSet.remove(integersIn: intRange)
|
|
mediaVerificationSet.remove(integersIn: intRange)
|
|
case .tag:
|
|
mediaVerificationSet.remove(integersIn: intRange)
|
|
}
|
|
removeHole(operation.range, space: operation.space)
|
|
}
|
|
let everywhereTestRanges = everywhereVerificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ... Int32($0.upperBound - 1)) })
|
|
let mediaTestRanges = mediaVerificationSet.rangeView.map({ ClosedRange(Int32($0.lowerBound) ... Int32($0.upperBound - 1)) })
|
|
expectHoles(space: .everywhere, everywhereTestRanges)
|
|
expectHoles(space: .tag(.media), mediaTestRanges)
|
|
}
|
|
}
|
|
|
|
func _testDirectAccessPerformance() {
|
|
self.beginTestDirectAccessPerformance(compactValuesOnCreation: false)
|
|
}
|
|
|
|
func _testDirectAccessPerformanceCompact() {
|
|
self.beginTestDirectAccessPerformance(compactValuesOnCreation: true)
|
|
}
|
|
|
|
func _testBlobExtractPerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(4000)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 4000, length: 4000, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 1000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
if let value = valueBox.get(table, key: key) {
|
|
var i = 0
|
|
let length = value.length
|
|
if i < length {
|
|
var output: Int32 = 0
|
|
value.read(&output, offset: i, length: 4)
|
|
i += 4
|
|
}
|
|
}
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func _testIncrementalBlobExtractPerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(4000)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 4000, length: 4000, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
valueBox.read(table, key: key, { length, read in
|
|
var i = 0
|
|
if i < length {
|
|
var output: Int32 = 0
|
|
read(&output, i, 4)
|
|
i += 4
|
|
}
|
|
})
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func _testBlobUpdatePerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
let buffer = WriteBuffer()
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
if let value = valueBox.get(table, key: key) {
|
|
var output: Int32 = 0
|
|
value.read(&output, offset: 0, length: 4)
|
|
output += 1
|
|
buffer.reset()
|
|
buffer.write(&output, offset: 0, length: 4)
|
|
valueBox.set(table, key: key, value: buffer)
|
|
}
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func _testBlobIncrementalUpdatePerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: false)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
valueBox.readWrite(table, key: key, { size, read, write in
|
|
var output: Int32 = 0
|
|
read(&output, 0, 4)
|
|
output += 1
|
|
write(&output, 0, 4)
|
|
})
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
private func beginTestDirectAccessPerformance(compactValuesOnCreation: Bool) {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: compactValuesOnCreation)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
let _ = valueBox.get(table, key: key)
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func _testDirectWritePerformance() {
|
|
self.beginTestDirectWritePerformance(compactValuesOnCreation: false)
|
|
}
|
|
|
|
func _testDirectWritePerformanceCompact() {
|
|
self.beginTestDirectWritePerformance(compactValuesOnCreation: true)
|
|
}
|
|
|
|
private func beginTestDirectWritePerformance(compactValuesOnCreation: Bool) {
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: compactValuesOnCreation)
|
|
let valueBox = self.postbox!.valueBox
|
|
|
|
self.startMeasuring()
|
|
|
|
let memory = malloc(4)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 4, length: 4, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 40000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
for key in keys.shuffled() {
|
|
let _ = valueBox.get(table, key: key)
|
|
}
|
|
self.stopMeasuring()
|
|
|
|
valueBox.removeAllFromTable(table)
|
|
})
|
|
}
|
|
|
|
func _testRangeAccessPerformance() {
|
|
self.beginTestRangeAccessPerformance(compactValuesOnCreation: false)
|
|
}
|
|
|
|
func _testRangeAccessPerformanceCompact() {
|
|
self.beginTestRangeAccessPerformance(compactValuesOnCreation: true)
|
|
}
|
|
|
|
func _testBinarySearchAccessPerformance() {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: true)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
|
|
var randomSpacedKeys: [Int32] = []
|
|
for _ in 0 ... 1000000 {
|
|
randomSpacedKeys.append(Int32(arc4random_uniform(100_000_000)))
|
|
}
|
|
randomSpacedKeys.sort()
|
|
|
|
for i in 0 ..< randomSpacedKeys.count {
|
|
let key = ValueBoxKey(length: 16)
|
|
key.setUInt32(0, value: 200)
|
|
key.setUInt32(4, value: 300)
|
|
key.setInt32(8, value: Int32(randomSpacedKeys[i]))
|
|
key.setInt32(12, value: Int32(i))
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
|
|
let lowerBound = ValueBoxKey(length: 8)
|
|
lowerBound.setUInt32(0, value: 200)
|
|
lowerBound.setUInt32(4, value: 300)
|
|
|
|
let upperBound = ValueBoxKey(length: 16)
|
|
upperBound.setUInt32(0, value: 200)
|
|
upperBound.setUInt32(4, value: 301)
|
|
upperBound.setUInt32(8, value: UInt32.max)
|
|
upperBound.setUInt32(12, value: UInt32.max)
|
|
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for i in 0 ... 1000 {
|
|
var startingLowerIndexValue: Int32?
|
|
valueBox.range(table, start: lowerBound, end: upperBound, keys: { key in
|
|
startingLowerIndexValue = key.getInt32(8)
|
|
return false
|
|
}, limit: 1)
|
|
|
|
var startingUpperIndexValue: Int32?
|
|
valueBox.range(table, start: upperBound, end: lowerBound, keys: { key in
|
|
startingUpperIndexValue = key.getInt32(8)
|
|
return false
|
|
}, limit: 1)
|
|
|
|
guard let startingLowerIndex = startingLowerIndexValue, let startingUpperIndex = startingUpperIndexValue else {
|
|
XCTAssert(false)
|
|
continue
|
|
}
|
|
|
|
var lowerIndex: Int32 = startingLowerIndex
|
|
var upperIndex: Int32 = startingUpperIndex
|
|
var rangeToLower = false
|
|
|
|
var readCount = 0
|
|
|
|
var found = false
|
|
while true {
|
|
readCount += 1
|
|
let currentIndex = Int32((Int64(lowerIndex) + Int64(upperIndex)) / 2)
|
|
let key = ValueBoxKey(length: 12)
|
|
key.setUInt32(0, value: 200)
|
|
key.setUInt32(4, value: 300)
|
|
key.setInt32(8, value: currentIndex)
|
|
|
|
var foundValue: (Int32, Int32)?
|
|
if !rangeToLower {
|
|
valueBox.range(table, start: key, end: upperBound, keys: { key in
|
|
foundValue = (key.getInt32(8), key.getInt32(12))
|
|
return false
|
|
}, limit: 1)
|
|
} else {
|
|
valueBox.range(table, start: key, end: lowerBound, keys: { key in
|
|
foundValue = (key.getInt32(8), key.getInt32(12))
|
|
return false
|
|
}, limit: 1)
|
|
}
|
|
|
|
if let (foundKey, foundValue) = foundValue {
|
|
if foundValue == Int32(i) {
|
|
found = true
|
|
break
|
|
} else if lowerIndex > upperIndex {
|
|
break
|
|
} else {
|
|
if foundValue > Int(i) {
|
|
upperIndex = foundKey - 1
|
|
rangeToLower = true
|
|
} else {
|
|
lowerIndex = foundKey + 1
|
|
rangeToLower = false
|
|
}
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
XCTAssert(false)
|
|
}
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
|
|
func beginTestRangeAccessPerformance(compactValuesOnCreation: Bool) {
|
|
let table = ValueBoxTable(id: 1000, keyType: .binary, compactValuesOnCreation: compactValuesOnCreation)
|
|
|
|
let valueBox = self.postbox!.valueBox
|
|
let memory = malloc(250)!
|
|
let value = MemoryBuffer(memory: memory, capacity: 250, length: 250, freeWhenDone: true)
|
|
var keys: [ValueBoxKey] = []
|
|
for _ in 0 ... 100000 {
|
|
let key = ValueBoxKey(length: 16)
|
|
arc4random_buf(key.memory, 16)
|
|
keys.append(key)
|
|
valueBox.set(table, key: key, value: value)
|
|
}
|
|
let upperBound = ValueBoxKey(length: 16)
|
|
upperBound.setUInt32(0, value: UInt32.max)
|
|
upperBound.setUInt32(4, value: UInt32.max)
|
|
upperBound.setUInt32(8, value: UInt32.max)
|
|
upperBound.setUInt32(12, value: UInt32.max)
|
|
|
|
self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: {
|
|
self.startMeasuring()
|
|
for key in keys.shuffled() {
|
|
valueBox.range(table, start: key.prefix(12), end: upperBound, keys: { _ in
|
|
return false
|
|
}, limit: 1)
|
|
let _ = valueBox.get(table, key: key)
|
|
}
|
|
self.stopMeasuring()
|
|
})
|
|
}
|
|
}
|