@streamr/dht 100.1.1 → 100.2.0

package/test/benchmark/kademlia-simulation/KademliaSimulation.ts

@@ -1,94 +0,0 @@
-/* eslint-disable no-console */
-
-import { SimulationNode } from './SimulationNode'
-import fs from 'fs'
-import { getDhtAddressFromRaw } from '../../../src/identifiers'
-
-export class KademliaSimulation {
-    
-    private static readonly NUM_NODES = 1000
-    private static readonly ID_LENGTH = 8
-
-    private readonly nodeNamesById: Record<string, number> = {} 
-    private readonly nodes: SimulationNode[] = []
-
-    private readonly dhtIds: Array<{ type: string, data: Array<number> }>
-    private readonly groundTruth: Record<string, Array<{ name: string, distance: number, id: { type: string, data: Array<number> } }>>
-
-    constructor() {
-        if (!fs.existsSync('test/data/nodeids.json')) {
-            throw new Error('Cannot find test/data/nodeids.json, please run "npm run prepare-kademlia-simulation first"')
-        }
-        this.dhtIds = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
-        this.groundTruth = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
-    }
-
-    public run(): void {
-        for (let i = 0; i < KademliaSimulation.NUM_NODES; i++) {
-            const node = new SimulationNode(getDhtAddressFromRaw(Buffer.from(this.dhtIds[i].data.slice(0, KademliaSimulation.ID_LENGTH))))
-            this.nodeNamesById[JSON.stringify(node.getContact().id)] = i
-            this.nodes.push(node)
-            node.joinDht(this.nodes[0])
-           
-            process.stdout.write('.')
-        }
-
-        let minimumCorrectNeighbors = Number.MAX_SAFE_INTEGER
-        
-        let sumCorrectNeighbors = 0
-        let sumKbucketSize = 1
-        let sumOutgoingRpcCalls = 0
-        let maxOutgoingRpcCalls = 0
-
-        for (let i = this.nodes.length - 1; i >= 0; i--) {
-            
-            const outgoingRpcCallCount = this.nodes[i].getOutgoingRpcCallCount()
-            console.log('-----------')
-            console.log('Node: ' + i)
-            console.log('Kbucket size: ' + this.nodes[i].getKBucketSize())
-            console.log('Num incoming RPC calls: ' + this.nodes[i].getIncomingRpcCallCount())
-            console.log('Num outgoing RPC calls: ' + outgoingRpcCallCount)
-    
-            sumOutgoingRpcCalls += outgoingRpcCallCount
-    
-            if (maxOutgoingRpcCalls < outgoingRpcCallCount) {
-                maxOutgoingRpcCalls = outgoingRpcCallCount
-            }
-
-            const kademliaNeighbors = this.nodes[i].getNeightborList().getContactIds()
-
-            let correctNeighbors = 0
-            for (let j = 0; j < this.groundTruth[i + ''].length; j++) {
-                if (this.groundTruth[i + ''][j].name != (this.nodeNamesById[JSON.stringify(kademliaNeighbors[j])] + '')) {
-                    break
-                }
-                correctNeighbors++
-            }
-
-            if (correctNeighbors < minimumCorrectNeighbors) {
-                minimumCorrectNeighbors = correctNeighbors
-            }
-
-            console.log('Correct neighbors: ' + correctNeighbors)
-
-            if (i > 0) {                
-                sumKbucketSize += this.nodes[i].getKBucketSize()
-                sumCorrectNeighbors += correctNeighbors
-            }
-        }
-
-        const avgCorrectNeighbors = sumCorrectNeighbors / (KademliaSimulation.NUM_NODES - 1)
-        const avgKbucketSize = sumKbucketSize / (KademliaSimulation.NUM_NODES - 1)
-        const avgOutgoingRpcCallCount = sumOutgoingRpcCalls / (KademliaSimulation.NUM_NODES - 1)
-
-        console.log('----------- Simulation results ------------------')
-        console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
-        console.log('Average correct neighbors: ' + avgCorrectNeighbors)
-        console.log('Average Kbucket size: ' + avgKbucketSize)
-        console.log('Average number of outgoing RPC calls: ' + avgOutgoingRpcCallCount)
-        console.log('MAX number of outgoing RPC calls: ' + maxOutgoingRpcCalls)
-    }
-}
-
-const simulation = new KademliaSimulation()
-simulation.run()

package/test/benchmark/kademlia-simulation/SimulationNode.ts

@@ -1,129 +0,0 @@
-import KBucket from 'k-bucket'
-import { Contact } from './Contact'
-import { SortedContactList } from '../../../src/dht/contact/SortedContactList'
-import { DhtAddress, getRawFromDhtAddress } from '../../../src/identifiers'
-
-export class SimulationNode {
-
-    private numberOfNodesPerKBucket = 1
-    private K = 8
-    private ALPHA = 1
-
-    private bucket: KBucket<Contact>
-    private ownContact: Contact
-
-    private incomingRpcCallCount = 0
-    private outgoingRpcCallCount = 0
-
-    private neighborList: SortedContactList<Contact>
-    private ownId: DhtAddress
-
-    constructor(ownId: DhtAddress) {
-        this.ownId = ownId
-        this.ownContact = new Contact(this.ownId, this)
-        this.bucket = new KBucket({
-            localNodeId: getRawFromDhtAddress(this.ownId),
-            numberOfNodesPerKBucket: this.numberOfNodesPerKBucket
-        })
-
-        this.neighborList = new SortedContactList({ 
-            referenceId: this.ownId,
-            maxSize: 1000,
-            allowToContainReferenceId: false,
-            emitEvents: false
-        })
-    }
-
-    // For simulation use
-
-    public getNeightborList(): SortedContactList<Contact> {
-        return this.neighborList
-    }
-    public getContact(): Contact {
-        return this.ownContact
-    }
-
-    public getKBucketSize(): number {
-        return this.bucket.count()
-    }
-
-    public getIncomingRpcCallCount(): number {
-        return this.incomingRpcCallCount
-    }
-
-    public getOutgoingRpcCallCount(): number {
-        return this.outgoingRpcCallCount
-    }
-
-    // RPC call
-
-    public getClosestNodesTo(id: DhtAddress, caller: SimulationNode): Contact[] {
-        this.incomingRpcCallCount++
-        const idValue = getRawFromDhtAddress(id)
-        const ret = this.bucket.closest(idValue)
-        if (!this.bucket.get(idValue)) {
-            const contact = new Contact(id, caller)
-            this.bucket.add(contact)
-            this.neighborList.addContact(contact)
-        }
-        return ret
-    }
-
-    private findMoreContacts(contactList: Contact[], shortlist: SortedContactList<Contact>) {
-        contactList.forEach((contact) => {
-            shortlist.setContacted(contact.getNodeId())
-            shortlist.setActive(contact.getNodeId())
-            this.outgoingRpcCallCount++
-            const returnedContacts = contact.dhtNode!.getClosestNodesTo(this.ownId, this)
-            shortlist.addContacts(returnedContacts)
-            returnedContacts.forEach((returnedContact: Contact) => {
-                if (!this.bucket.get(returnedContact.id)) {
-                    this.bucket.add(returnedContact)
-                }
-            })
-        })
-    }
-
-    public joinDht(entryPoint: SimulationNode): void {
-        if (entryPoint.getContact().getNodeId() === this.ownId) {
-            return
-        }
-
-        this.bucket.add(entryPoint.getContact())
-        const closest = this.bucket.closest(getRawFromDhtAddress(this.ownId), this.ALPHA)
-
-        this.neighborList.addContacts(closest)
-
-        /* eslint-disable no-constant-condition */
-        while (true) {
-            let oldClosestContactId = this.neighborList.getClosestContactId()
-            let uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)
-            if (uncontacted.length === 0) {
-                return
-            }
-
-            this.findMoreContacts(uncontacted, this.neighborList)
-
-            if (oldClosestContactId === this.neighborList.getClosestContactId()) {
-                uncontacted = this.neighborList.getUncontactedContacts(this.K)
-                if (uncontacted.length === 0) {
-                    return
-                }
-
-                while (true) {
-                    oldClosestContactId = this.neighborList.getClosestContactId()
-                    this.findMoreContacts(uncontacted, this.neighborList)
-
-                    if (this.neighborList.getActiveContacts().length >= this.K ||
-                        (oldClosestContactId === this.neighborList.getClosestContactId())) {
-                        return
-                    }
-                    uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)
-                    if (uncontacted.length === 0) {
-                        return
-                    }
-                }
-            }
-        }
-    }
-}

package/test/data/generateGroundTruthData.ts

@@ -1,71 +0,0 @@
-import fs from 'fs'
-import crypto from 'crypto'
-import KBucket from 'k-bucket'
-import { DhtAddressRaw } from '../../src/identifiers'
-
-const ID_LENGTH = 20
-const NUM_NODES = 900
-const NUM_NEAREST = 10
-
-const generateId = function(): DhtAddressRaw {
-    return crypto.randomBytes(ID_LENGTH)
-}
-
-const findNNearestNeighbors = function(ownIndex: number, ownId: DhtAddressRaw, nodes: Array<DhtAddressRaw>, n: number): Array<number> {
-    const retIndex: Array<number> = []
-
-    for (let i = 0; i < n; i++) {
-        let closestIndex: number = Number.MAX_VALUE 
-        let closestDistance: number = Number.MAX_VALUE
-        
-        for (let j = 0; j < nodes.length; j++) {
-            if (j == ownIndex || retIndex.includes(j)) {
-                continue
-            }
-            const distance = KBucket.distance(ownId, nodes[j])
-            if (distance < closestDistance) {
-                closestDistance = distance
-                closestIndex = j
-            }
-        }
-        retIndex.push(closestIndex)
-    }
-    return retIndex
-}
-
-const writer = fs.createWriteStream('nodeids.json', {})
-const neighborWriter = fs.createWriteStream('orderedneighbors.json', {})
-
-neighborWriter.write('{\n')
-
-const nodes: Array<DhtAddressRaw> = []
-
-// generate nodeIds
-
-for (let i = 0; i < NUM_NODES; i++) {
-    const id = generateId()
-    nodes.push(id)
-}
-
-writer.write(JSON.stringify(nodes, null, 4))
-writer.end()
-
-for (let i = 0; i < NUM_NODES; i++) {
-
-    const neighborIds = findNNearestNeighbors(i, nodes[i], nodes, NUM_NEAREST)
-
-    const neighborNames: Array<{ name: number, distance: number, id: DhtAddressRaw }> = []
-    // eslint-disable-next-line @typescript-eslint/prefer-for-of
-    for (let j = 0; j < neighborIds.length; j++) {
-        neighborNames.push({ name: neighborIds[j], distance: KBucket.distance(nodes[i], nodes[neighborIds[j]]), id: nodes[neighborIds[j]] })
-    }
-    neighborWriter.write('"' + i + '": ' + JSON.stringify(neighborNames))
-    process.stdout.write('.')
-
-    if (i != NUM_NODES - 1) {
-        neighborWriter.write(',\n')
-    }
-}
-
-neighborWriter.write('}')
-neighborWriter.end()