git ssb - rewrite · wanderer🌟/js-primea-hypervisor@3f8c23e3

Commit 3f8c23e36f6d90d0c86b778fb27c24c5aa57c8a1

rewrite

Signed-off-by: wanderer <mjbecze@gmail.com>

wanderer committed on 1/19/2018, 2:14:18 AM
Parent: df84d7871808036fce1c56eaa79c0565b9b5ddb6

Files changed

actor.js	changed
benchmark/index.js	changed
inbox.js	changed
index.js	changed
package.json	changed
scheduler.js	changed
tests/index.js	changed
message.js	added

actor.jsView
		@@ -1,6 +1,5 @@
1	1	const Pipe = require('buffer-pipe')
2		-const Cap = require('primea-capability')
3	2	const leb128 = require('leb128').unsigned
4	3	const Inbox = require('./inbox.js')
5	4
6	5	module.exports = class Actor {
		@@ -15,9 +14,8 @@
15	14	*/
16	15	constructor (opts) {
17	16	Object.assign(this, opts)
18	17
19		- this.container = new opts.container.Constructor(this, opts.container.args)
20	18	this.inbox = new Inbox({
21	19	actor: this,
22	20	hypervisor: opts.hypervisor
23	21	})
		@@ -26,17 +24,8 @@
26	24	this.running = false
27	25	}
28	26
29	27	/**
30		- * Mints a new capabilitly with a given tag
31		- * @param {*} tag - a tag which can be used to identify caps
32		- * @return {Object}
33		- */
34		- mintCap (tag = 0, funcIndex = 0) {
35		- return new Cap(this.id, tag, funcIndex)
36		- }
37		-
38		- /**
39	28	* adds a message to this actor's message queue
40	29	* @param {string} portName
41	30	* @param {object} message
42	31	*/
		@@ -48,41 +37,36 @@
48	37	this._startMessageLoop()
49	38	}
50	39	}
51	40
52		- /**
53		- * runs the creation routine for the actor
54		- * @param {object} message
55		- * @returns {Promise}
56		- */
57		- create (message) {
58		- this.running = true
59		- return this.runMessage(message, 'onCreation').then(() => {
60		- this._startMessageLoop()
61		- })
62		- }
63		-
64	41	// waits for the next message
65	42	async _startMessageLoop () {
66	43	// this ensure we only every have one loop running at a time
67	44	while (!this.inbox.isEmpty) {
68		- const message = await this.inbox.nextMessage(0)
	45	+ const message = await this.inbox.nextMessage()
69	46	await this.runMessage(message)
70	47	}
71	48	this.running = false
72	49	// wait for state ops to finish
73	50	await this.state.done()
74	51	setTimeout(() => {
75	52	if (!this.running) {
76		- this.container.onIdle()
	53	+ this.shutdown()
77	54	}
78	55	}, 0)
79	56	}
80	57
81	58	serializeMetaData () {
82	59	return Actor.serializeMetaData(this.type, this.nonce)
83	60	}
84	61
	62	+ getFuncRef (name) {
	63	+ return {
	64	+ name,
	65	+ destId: this.id
	66	+ }
	67	+ }
	68	+
85	69	static serializeMetaData (type, nonce = 0) {
86	70	const p = new Pipe()
87	71	leb128.write(type, p)
88	72	leb128.write(nonce, p)
		@@ -109,21 +93,22 @@
109	93
110	94	/**
111	95	* Runs the startup routine for the actor
112	96	*/
113		- startup () {
114		- return this.container.onStartup()
	97	+ async startup () {
	98	+ this.instance = await this.container.instance(this)
115	99	}
116	100
117	101	/**
118	102	* run the Actor with a given message
119	103	* @param {object} message - the message to run
120	104	* @param {String} method - which method to run
121	105	* @returns {Promise}
122	106	*/
123		- async runMessage (message, method = 'onMessage') {
	107	+ async runMessage (message) {
124	108	try {
125		- await this.container[method](message)
	109	+ this.currentMessage = message
	110	+ await this.instance.exports[message.funcRef.name](...message.funcArguments)
126	111	} catch (e) {
127	112	message.emit('execution:error', e)
128	113	}
129	114	}
		@@ -141,11 +126,11 @@
141	126	* creates an actor
142	127	* @param {Integer} type - the type id for the container
143	128	* @param {Object} message - an intial [message](https://github.com/primea/js-primea-message) to send newly created actor
144	129	*/
145		- createActor (type, message) {
	130	+ createActor (type, code) {
146	131	const id = this._generateNextId()
147		- return this.hypervisor.createActor(type, message, id)
	132	+ return this.hypervisor.createActor(type, code, id)
148	133	}
149	134
150	135	_generateNextId () {
151	136	const id = {
		@@ -161,11 +146,11 @@
161	146	* sends a message to a given port
162	147	* @param {Object} portRef - the port
163	148	* @param {Message} message - the message
164	149	*/
165		- send (cap, message) {
	150	+ send (message) {
166	151	message._fromTicks = this.ticks
167	152	message._fromId = this.id
168	153
169		- return this.hypervisor.send(cap, message)
	154	+ return this.hypervisor.send(message)
170	155	}
171	156	}

benchmark/index.jsView
		@@ -1,6 +1,5 @@
1		-const AbstractContainer = require('primea-abstract-container')
2		-const Message = require('primea-message')
	1	+const Message = require('../message.js')
3	2	const Hypervisor = require('../')
4	3
5	4	const level = require('level-browserify')
6	5	const RadixTree = require('dfinity-radix-tree')
		@@ -8,70 +7,94 @@
8	7
9	8	let numOfMsg = 0
10	9	const messageOrder = {}
11	10
12		-async function main (numOfActors, depth) {
13		- class BenchmarkContainer extends AbstractContainer {
14		- onCreation () {}
15		- async onMessage (message) {
16		- // console.log('run queue', this.actor.inbox._queue)
17		- // console.log('from', message._fromId.toString('hex'), 'to: ', this.actor.id.toString('hex'), this.actor.ticks, message._fromTicks)
18		- const last = messageOrder[this.actor.id.toString('hex')]
19		- if (last && last > message._fromTicks) {
20		- console.log(last, message._fromTicks)
21		- // console.log(this.actor.hypervisor.scheduler.instances)
22		- } else {
	11	+class BenchmarkContainer {
	12	+ static validate () {}
	13	+ static compile () {}
	14	+ static get typeId () {
	15	+ return 9
	16	+ }
	17	+
	18	+ static exports (m, id) {
	19	+ return Object.keys(this.functions()).map(name => {
	20	+ return {
	21	+ name,
	22	+ destId: id
23	23	}
24		- messageOrder[this.actor.id.toString('hex')] = message._fromTicks
25		- numOfMsg++
26		- this.actor.incrementTicks(1)
27		- const cap = message.caps.pop()
28		- if (cap) {
29		- return this.actor.send(cap, message)
	24	+ })
	25	+ }
	26	+ static instance (actor) {
	27	+ return {
	28	+ exports: this.functions(actor)
	29	+ }
	30	+ }
	31	+ static functions (actor) {
	32	+ return {
	33	+ onMessage: function () {
	34	+ const refs = [...arguments]
	35	+ const ref = refs.pop()
	36	+ // console.log('run queue', this.actor.inbox._queue)
	37	+ // console.log('from', message._fromId.toString('hex'), 'to: ', this.actor.id.toString('hex'), this.actor.ticks, message._fromTicks)
	38	+ // const last = messageOrder[actor.id.toString('hex')]
	39	+ // const message = actor.currentMessage
	40	+ // if (last && last > message._fromTicks) {
	41	+ // console.log(last, message._fromTicks)
	42	+ // // console.log(this.actor.hypervisor.scheduler.instances)
	43	+ // }
	44	+ // messageOrder[actor.id.toString('hex')] = message._fromTicks
	45	+ numOfMsg++
	46	+ actor.incrementTicks(10)
	47	+ if (ref) {
	48	+ return actor.send(new Message({
	49	+ funcRef: ref,
	50	+ funcArguments: refs
	51	+ }))
	52	+ }
30	53	}
31	54	}
32		- static get typeId () {
33		- return 9
34		- }
35	55	}
	56	+}
36	57
	58	+async function main (numOfActors, depth) {
37	59	const tree = new RadixTree({
38	60	db: db
39	61	})
40	62
41	63	const hypervisor = new Hypervisor(tree)
42	64	hypervisor.registerContainer(BenchmarkContainer)
43	65
44		- const caps = []
	66	+ const refernces = []
45	67	let _numOfActors = numOfActors
46	68	while (_numOfActors--) {
47		- const cap = await hypervisor.createActor(BenchmarkContainer.typeId, new Message())
48		- caps.push(cap)
	69	+ const {exports} = await hypervisor.createActor(BenchmarkContainer.typeId)
	70	+ refernces.push(exports[0])
49	71	}
	72	+ // console.log(refernces)
50	73	_numOfActors = numOfActors
51	74	let msgs = []
52	75	while (_numOfActors--) {
53		- const message = new Message()
54		- msgs.push(message)
55	76	let _depth = depth
	77	+ const funcArguments = []
56	78	while (_depth--) {
57	79	const r = Math.floor(Math.random() * numOfActors)
58		- const cap = caps[r]
59		- message.caps.push(cap)
	80	+ const ref = refernces[r]
	81	+ funcArguments.push(ref)
60	82	}
	83	+ const message = new Message({
	84	+ funcArguments,
	85	+ funcRef: refernces[_numOfActors]
	86	+ })
	87	+ msgs.push(message)
61	88	}
62	89
63	90	let start = new Date()
64		- // hypervisor.scheduler.lock(Buffer.from([0xff]))
65		- msgs.forEach((msg, index) => {
66		- hypervisor.send(caps[index], msg)
67		- })
	91	+ await Promise.all(msgs.map((msg) => hypervisor.send(msg)))
68	92	console.log('done sending')
69	93	await hypervisor.scheduler.wait(Infinity)
70		- // console.log(JSON.stringify(hypervisor.tree.root, null ,2))
71	94	const end = new Date() - start
72	95	console.info('Execution time: %dms', end)
73	96	console.log('messages processed', numOfActors * depth + numOfActors)
74	97	console.log('messages processed', numOfMsg)
75	98	}
76	99
77		-main(55, 10)
	100	+main(1000, 10)

inbox.jsView
		@@ -7,8 +7,9 @@
7	7	if (messageA._fromTicks !== messageB._fromTicks) {
8	8	return messageA._fromTicks > messageB._fromTicks
9	9	} else {
10	10	// sender id
	11	+ // console.log('here')
11	12	return Buffer.compare(messageA._fromId, messageB._fromId)
12	13	}
13	14	}
14	15
		@@ -23,9 +24,8 @@
23	24	constructor (opts) {
24	25	this.actor = opts.actor
25	26	this.hypervisor = opts.hypervisor
26	27	this._queue = []
27		- this._waitingTagsQueue = []
28	28	this._oldestMessagePromise = new Promise((resolve, reject) => {
29	29	this._oldestMessageResolve = resolve
30	30	})
31	31	}
		@@ -50,56 +50,18 @@
50	50	}
51	51	}
52	52
53	53	/**
54		- * Waits for a message sent with a capablitly that has one of the given tags
55		- * @param {Array<*>} tags
56		- * @param {Integer} timeout
57		- * @returns {Promise}
58		- */
59		- async nextTaggedMessage (tags, timeout) {
60		- this._waitingTags = new Set(tags)
61		- this._queue = this._queue.filter(message => !this._queueTaggedMessage(message))
62		-
63		- // todo: add saturation test
64		- const message = await this.nextMessage(timeout)
65		- delete this._waitingTags
66		- this._waitingTagsQueue.forEach(message => this._queueMessage(message))
67		- this._waitingTagsQueue = []
68		-
69		- return message
70		- }
71		-
72		- /**
73	54	* Waits for the the next message if any
74	55	* @param {Integer} timeout
75	56	* @returns {Promise}
76	57	*/
77		- async nextMessage (timeout) {
78		- if (!this._gettingNextMessage) {
79		- this._gettingNextMessage = true
80		- } else {
81		- throw new Error('already waiting for next message')
82		- }
83		-
	58	+ async nextMessage () {
84	59	let message = this._getOldestMessage()
85		- if (message) {
86		- timeout = message._fromTicks
87		- } else {
88		- timeout += this.actor.ticks
89		- }
90		-
	60	+ let timeout = message._fromTicks
91	61	let oldestTime = this.hypervisor.scheduler.leastNumberOfTicks(this.actor.id)
92	62
93	63	while (true) {
94		- if (message) {
95		- // if there is a message that is "older" then the timeout, the lower
96		- // the timeout to the oldest message
97		- if (message._fromTicks < timeout) {
98		- timeout = message._fromTicks
99		- }
100		- }
101		-
102	64	// if all actors are "older" then the time out then stop waiting for messages
103	65	// since we konw that we can not receive one
104	66	if (oldestTime >= timeout) {
105	67	break
		@@ -110,20 +72,23 @@
110	72	message = this._getOldestMessage()
111	73	}),
112	74	this._olderMessage(message).then(m => {
113	75	message = m
	76	+ // if there is a message that is "older" then the timeout, the lower
	77	+ // the timeout to the oldest message
	78	+ timeout = message._fromTicks
114	79	})
115	80	])
116	81	oldestTime = this.hypervisor.scheduler.leastNumberOfTicks(this.actor.id)
117	82	}
118		- this._gettingNextMessage = false
	83	+ message = this._deQueueMessage()
119	84	// if the message we recived had more ticks then we currently have then
120	85	// update our ticks to it, since we jumped forward in time
121	86	if (message && message._fromTicks > this.actor.ticks) {
122	87	this.actor.ticks = message._fromTicks
123	88	this.hypervisor.scheduler.update(this.actor)
124	89	}
125		- return this._deQueueMessage()
	90	+ return message
126	91	}
127	92
128	93	// returns a promise that resolve when a message older then the given message
129	94	// is recived
		@@ -131,35 +96,15 @@
131	96	return this._oldestMessagePromise
132	97	}
133	98
134	99	_getOldestMessage () {
135		- if (this._waitingTags) {
136		- return this._waitingTagsQueue[0]
137		- } else {
138		- return this._queue[0]
139		- }
	100	+ return this._queue[0]
140	101	}
141	102
142	103	_deQueueMessage () {
143		- if (this._waitingTags) {
144		- return this._waitingTagsQueue.shift()
145		- } else {
146		- return this._queue.shift()
147		- }
	104	+ return this._queue.shift()
148	105	}
149	106
150	107	_queueMessage (message) {
151		- if (!(this._waitingTags && this._queueTaggedMessage(message))) {
152		- binarySearchInsert(this._queue, messageArbiter, message)
153		- }
	108	+ binarySearchInsert(this._queue, messageArbiter, message)
154	109	}
155		-
156		- _queueTaggedMessage (message) {
157		- if (this._waitingTags.has(message.tag)) {
158		- this._waitingTags.delete(message.tag)
159		- binarySearchInsert(this._waitingTagsQueue, messageArbiter, message)
160		- return true
161		- } else {
162		- return false
163		- }
164		- }
165	110	}

index.jsView
		@@ -19,11 +19,10 @@
19	19	* @param {Object} cap - the capabilitly used to send the message
20	20	* @param {Object} message - the [message](https://github.com/primea/js-primea-message) to send
21	21	* @returns {Promise} a promise that resolves once the receiving container is loaded
22	22	*/
23		- async send (cap, message) {
24		- message.tag = cap.tag
25		- const id = cap.destId
	23	+ async send (message) {
	24	+ const id = message.funcRef.destId
26	25	const instance = await this.getActor(id)
27	26	instance.queue(message)
28	27	}
29	28
		@@ -42,8 +41,9 @@
42	41	nonce,
43	42	type
44	43	})
45	44
	45	+ await actor.startup()
46	46	// save the newly created instance
47	47	this.scheduler.update(actor)
48	48	return actor
49	49	}
		@@ -57,9 +57,8 @@
57	57	let actor = this.scheduler.getInstance(id)
58	58	if (!actor) {
59	59	const resolve = this.scheduler.lock(id)
60	60	actor = await this._loadActor(id)
61		- await actor.startup()
62	61	resolve(actor)
63	62	}
64	63	return actor
65	64	}
		@@ -69,22 +68,22 @@
69	68	* @param {Integer} type - the type id for the container
70	69	* @param {Object} message - an intial [message](https://github.com/primea/js-primea-message) to send newly created actor
71	70	* @param {Object} id - the id for the actor
72	71	*/
73		- async createActor (type, message, id = {nonce: this.nonce++, parent: null}) {
	72	+ async createActor (type, code, id = {nonce: this.nonce++, parent: null}) {
74	73	const encoded = encodedID(id)
75	74	const idHash = await this._getHashFromObj(encoded)
76	75	const metaData = Actor.serializeMetaData(type)
77	76
78	77	// save the container in the state
79	78	this.tree.set(idHash, metaData)
80		-
81		- // create the container instance
82		- const instance = await this._loadActor(idHash)
83		-
84		- // send the intialization message
85		- instance.create(message)
86		- return instance.mintCap()
	79	+ const Container = this._containerTypes[type]
	80	+ await Container.validate(code)
	81	+ const module = await Container.compile(code)
	82	+ return {
	83	+ id: idHash,
	84	+ exports: Container.exports(module, idHash)
	85	+ }
87	86	}
88	87
89	88	// get a hash from a POJO
90	89	_getHashFromObj (obj) {
		@@ -107,13 +106,10 @@
107	106	* @param {Class} Constructor - a Class for instantiating the container
108	107	* @param {*} args - any args that the contructor takes
109	108	* @param {Integer} typeId - the container's type identification ID
110	109	*/
111		- registerContainer (Constructor, args, typeId = Constructor.typeId) {
112		- this._containerTypes[typeId] = {
113		- Constructor,
114		- args
115		- }
	110	+ registerContainer (Constructor) {
	111	+ this._containerTypes[Constructor.typeId] = Constructor
116	112	}
117	113	}
118	114
119	115	function encodedID (id) {

package.jsonView
		@@ -32,8 +32,9 @@
32	32	"license": "MPL-2.0",
33	33	"dependencies": {
34	34	"binary-search-insert": "^1.0.3",
35	35	"buffer-pipe": "0.0.2",
	36	+ "events": "^1.1.1",
36	37	"leb128": "0.0.4",
37	38	"primea-capability": "0.0.1",
38	39	"primea-message": "0.6.1",
39	40	"safe-buffer": "^5.1.1",

scheduler.jsView
		@@ -111,8 +111,9 @@
111	111	// checks outstanding waits to see if they can be resolved
112	112	_checkWaits () {
113	113	// if there are no instances, clear any remaining waits
114	114	if (!this.instances.size) {
	115	+ // console.log('here', this._waits)
115	116	this._waits.forEach(wait => wait.resolve())
116	117	this._waits = []
117	118	return
118	119	}

tests/index.jsView
		@@ -1,23 +1,36 @@
1	1	const tape = require('tape')
2		-const AbstractContainer = require('primea-abstract-container')
3		-const Message = require('primea-message')
	2	+const Message = require('../message.js')
4	3	const Hypervisor = require('../')
5	4
6	5	const level = require('level-browserify')
7	6	const RadixTree = require('dfinity-radix-tree')
8	7	const db = level('./testdb')
9	8
10		-class BaseContainer extends AbstractContainer {
11		- onCreation () {}
	9	+class BaseContainer {
	10	+ static validate () {}
	11	+ static compile () {}
12	12	static get typeId () {
13	13	return 9
14	14	}
	15	+
	16	+ static exports (m, id) {
	17	+ return Object.keys(this.functions()).map(name => {
	18	+ return {
	19	+ name,
	20	+ destId: id
	21	+ }
	22	+ })
	23	+ }
	24	+ static instance (actor) {
	25	+ return {
	26	+ exports: this.functions(actor)
	27	+ }
	28	+ }
15	29	}
16	30
17	31	tape('basic', async t => {
18	32	t.plan(2)
19		- let message
20	33	const expectedState = {
21	34	'/': Buffer.from('926de6b7eb39cfa8d7f8a44d1ef191d3bcb765a7', 'hex')
22	35	}
23	36
		@@ -25,28 +38,34 @@
25	38	db: db
26	39	})
27	40
28	41	class testVMContainer extends BaseContainer {
29		- onMessage (m, tag) {
30		- t.true(m === message, 'should recive a message')
	42	+ static functions () {
	43	+ return {
	44	+ onMessage: (m) => {
	45	+ t.true(m === 1, 'should recive a message')
	46	+ }
	47	+ }
31	48	}
32	49	}
33	50
34	51	const hypervisor = new Hypervisor(tree)
35	52	hypervisor.registerContainer(testVMContainer)
36	53
37		- let rootCap = await hypervisor.createActor(testVMContainer.typeId, new Message())
	54	+ let {exports} = await hypervisor.createActor(testVMContainer.typeId)
38	55
39		- message = new Message()
40		- hypervisor.send(rootCap, message)
	56	+ const message = new Message({
	57	+ funcRef: exports[0],
	58	+ funcArguments: [1]
	59	+ })
	60	+ hypervisor.send(message)
41	61
42	62	const stateRoot = await hypervisor.createStateRoot()
43	63	t.deepEquals(stateRoot, expectedState, 'expected root!')
44	64	})
45	65
46	66	tape('two communicating actors', async t => {
47	67	t.plan(2)
48		- let message
49	68	const expectedState = {
50	69	'/': Buffer.from('a4c7ceacd8c867ae1d0b472d8bffa3cb10048331', 'hex')
51	70	}
52	71
		@@ -54,17 +73,28 @@
54	73	db: db
55	74	})
56	75
57	76	class testVMContainerA extends BaseContainer {
58		- onCreation (m) {
59		- message = new Message()
60		- this.actor.send(m.caps[0], message)
	77	+ static functions (actor) {
	78	+ return {
	79	+ onMessage: (funcRef) => {
	80	+ const message = new Message({
	81	+ funcRef: funcRef,
	82	+ funcArguments: [2]
	83	+ })
	84	+ return actor.send(message)
	85	+ }
	86	+ }
61	87	}
62	88	}
63	89
64	90	class testVMContainerB extends BaseContainer {
65		- onMessage (m) {
66		- t.true(m === message, 'should recive a message')
	91	+ static functions () {
	92	+ return {
	93	+ onMessage: (args) => {
	94	+ t.true(args === 2, 'should recive a message')
	95	+ }
	96	+ }
67	97	}
68	98
69	99	static get typeId () {
70	100	return 8
		@@ -74,20 +104,23 @@
74	104	const hypervisor = new Hypervisor(tree)
75	105	hypervisor.registerContainer(testVMContainerA)
76	106	hypervisor.registerContainer(testVMContainerB)
77	107
78		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
79		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
80		- caps: [capB]
81		- }))
	108	+ const {exports: exportsB} = await hypervisor.createActor(testVMContainerB.typeId)
	109	+ const {exports: exportsA} = await hypervisor.createActor(testVMContainerA.typeId)
	110	+ const message = new Message({
	111	+ funcRef: exportsA[0],
	112	+ funcArguments: [exportsB[0]]
	113	+ })
82	114
	115	+ await hypervisor.send(message)
	116	+
83	117	const stateRoot = await hypervisor.createStateRoot()
84	118	t.deepEquals(stateRoot, expectedState, 'expected root!')
85	119	})
86	120
87	121	tape('three communicating actors', async t => {
88	122	t.plan(3)
89		- let message
90	123	const expectedState = {
91	124	'/': Buffer.from('4633ac4b9f8212e501b6c56906039ec081fbe5a3', 'hex')
92	125	}
93	126
		@@ -95,17 +128,28 @@
95	128	db: db
96	129	})
97	130
98	131	class testVMContainerA extends BaseContainer {
99		- onCreation (m) {
100		- message = new Message()
101		- this.actor.send(m.caps[0], message)
	132	+ static functions (actor) {
	133	+ return {
	134	+ onMessage: (funcRef) => {
	135	+ const message = new Message({
	136	+ funcRef: funcRef,
	137	+ funcArguments: [2]
	138	+ })
	139	+ actor.send(message)
	140	+ }
	141	+ }
102	142	}
103	143	}
104	144
105	145	class testVMContainerB extends BaseContainer {
106		- onMessage (m) {
107		- t.true(m === message, 'should recive a message')
	146	+ static functions () {
	147	+ return {
	148	+ onMessage: (arg) => {
	149	+ t.equals(arg, 2, 'should recive a message')
	150	+ }
	151	+ }
108	152	}
109	153
110	154	static get typeId () {
111	155	return 8
		@@ -115,46 +159,61 @@
115	159	const hypervisor = new Hypervisor(tree)
116	160	hypervisor.registerContainer(testVMContainerA)
117	161	hypervisor.registerContainer(testVMContainerB)
118	162
119		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
120		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
121		- caps: [capB]
122		- }))
	163	+ let {exports: exportsB} = await hypervisor.createActor(testVMContainerB.typeId)
	164	+ let {exports: exportsA0} = await hypervisor.createActor(testVMContainerA.typeId)
	165	+ let {exports: exportsA1} = await hypervisor.createActor(testVMContainerA.typeId)
123	166
124		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
125		- caps: [capB]
126		- }))
	167	+ const message0 = new Message({
	168	+ funcRef: exportsA0[0],
	169	+ funcArguments: [exportsB[0]]
	170	+ })
127	171
	172	+ const message1 = new Message({
	173	+ funcRef: exportsA1[0],
	174	+ funcArguments: [exportsB[0]]
	175	+ })
	176	+
	177	+ await hypervisor.send(message0)
	178	+ await hypervisor.send(message1)
	179	+
128	180	const stateRoot = await hypervisor.createStateRoot()
129	181	t.deepEquals(stateRoot, expectedState, 'expected root!')
130	182	})
131	183
132	184	tape('three communicating actors, with tick counting', async t => {
133	185	t.plan(3)
134		- let message
135	186	const expectedState = {
136	187	'/': Buffer.from('4633ac4b9f8212e501b6c56906039ec081fbe5a3', 'hex')
137	188	}
138	189
139	190	const tree = new RadixTree({
140	191	db: db
141	192	})
142	193
143		- let ticks = 1
144		-
145	194	class testVMContainerA extends BaseContainer {
146		- async onCreation (m) {
147		- this.actor.incrementTicks(ticks)
148		- ticks++
149		- message = new Message()
150		- this.actor.send(m.caps[0], message)
	195	+ static functions (actor) {
	196	+ return {
	197	+ onMessage: funcRef => {
	198	+ actor.incrementTicks(1)
	199	+ const message = new Message({
	200	+ funcRef: funcRef,
	201	+ funcArguments: [2]
	202	+ })
	203	+ actor.send(message)
	204	+ }
	205	+ }
151	206	}
152	207	}
153	208
154	209	class testVMContainerB extends BaseContainer {
155		- onMessage (m) {
156		- t.true(m, 'should recive a message')
	210	+ static functions (actor) {
	211	+ return {
	212	+ onMessage: arg => {
	213	+ t.equals(arg, 2, 'should recive a message')
	214	+ }
	215	+ }
157	216	}
158	217
159	218	static get typeId () {
160	219	return 8
		@@ -164,25 +223,31 @@
164	223	const hypervisor = new Hypervisor(tree)
165	224	hypervisor.registerContainer(testVMContainerA)
166	225	hypervisor.registerContainer(testVMContainerB)
167	226
168		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
169		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
170		- caps: [capB]
171		- }))
	227	+ let actorB = await hypervisor.createActor(testVMContainerB.typeId)
	228	+ let actorA0 = await hypervisor.createActor(testVMContainerA.typeId)
	229	+ let actorA1 = await hypervisor.createActor(testVMContainerA.typeId)
172	230
173		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
174		- caps: [capB]
175		- }))
	231	+ const message0 = new Message({
	232	+ funcRef: actorA0.exports[0],
	233	+ funcArguments: [actorB.exports[0]]
	234	+ })
176	235
	236	+ const message1 = new Message({
	237	+ funcRef: actorA1.exports[0],
	238	+ funcArguments: actorB.exports
	239	+ })
	240	+
	241	+ hypervisor.send(message0)
	242	+ hypervisor.send(message1)
	243	+
177	244	const stateRoot = await hypervisor.createStateRoot()
178		-
179	245	t.deepEquals(stateRoot, expectedState, 'expected root!')
180	246	})
181	247
182	248	tape('errors', async t => {
183	249	t.plan(3)
184		- let message
185	250	const expectedState = {
186	251	'/': Buffer.from('a4c7ceacd8c867ae1d0b472d8bffa3cb10048331', 'hex')
187	252	}
188	253
		@@ -190,21 +255,31 @@
190	255	db: db
191	256	})
192	257
193	258	class testVMContainerA extends BaseContainer {
194		- onCreation (m) {
195		- message = new Message()
196		- message.on('execution:error', () => {
197		- t.pass('should recive a exeption')
198		- })
199		- this.actor.send(m.caps[0], message)
	259	+ static functions (actor) {
	260	+ return {
	261	+ onMessage: funcRef => {
	262	+ const message = new Message({
	263	+ funcRef
	264	+ })
	265	+ message.on('execution:error', () => {
	266	+ t.pass('should recive a exeption')
	267	+ })
	268	+ actor.send(message)
	269	+ }
	270	+ }
200	271	}
201	272	}
202	273
203	274	class testVMContainerB extends BaseContainer {
204		- onMessage (m) {
205		- t.true(m === message, 'should recive a message')
206		- throw new Error('test error')
	275	+ static functions (actor) {
	276	+ return {
	277	+ onMessage: funcRef => {
	278	+ t.true(true, 'should recive a message')
	279	+ throw new Error('test error')
	280	+ }
	281	+ }
207	282	}
208	283
209	284	static get typeId () {
210	285	return 8
		@@ -214,20 +289,21 @@
214	289	const hypervisor = new Hypervisor(tree)
215	290	hypervisor.registerContainer(testVMContainerA)
216	291	hypervisor.registerContainer(testVMContainerB)
217	292
218		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
219		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
220		- caps: [capB]
221		- }))
222		-
	293	+ let {exports: exportsB} = await hypervisor.createActor(testVMContainerB.typeId)
	294	+ let {exports: exportsA} = await hypervisor.createActor(testVMContainerA.typeId)
	295	+ const message = new Message({
	296	+ funcRef: exportsA[0],
	297	+ funcArguments: exportsB
	298	+ })
	299	+ hypervisor.send(message)
223	300	const stateRoot = await hypervisor.createStateRoot()
224	301	t.deepEquals(stateRoot, expectedState, 'expected root!')
225	302	})
226	303
227	304	tape('actor creation', async t => {
228	305	t.plan(2)
229		- let message
230	306	const expectedState = {
231	307	'/': Buffer.from('f47377a763c91247e62138408d706a09bccaaf36', 'hex')
232	308	}
233	309
		@@ -235,24 +311,32 @@
235	311	db: db
236	312	})
237	313
238	314	class testVMContainerA extends BaseContainer {
239		- onCreation (m) {
240		- message = new Message()
241		- const cap = this.actor.mintCap()
242		- message.caps.push(cap)
243		- return this.actor.createActor(testVMContainerB.typeId, message)
	315	+ static functions (actor) {
	316	+ return {
	317	+ onCreation: async funcRef => {
	318	+ const {exports} = await actor.createActor(testVMContainerB.typeId)
	319	+ const message = new Message({
	320	+ funcRef: exports[0],
	321	+ funcArguments: [actor.getFuncRef('onMessage')]
	322	+ })
	323	+ actor.send(message)
	324	+ },
	325	+ onMessage: data => {
	326	+ t.equals(data, 'test', 'should recive a response message')
	327	+ }
	328	+ }
244	329	}
245		-
246		- onMessage (m) {
247		- t.equals(m.data, 'test', 'should recive a response message')
248		- }
249	330	}
250	331
251	332	class testVMContainerB extends BaseContainer {
252		- onCreation (m) {
253		- const cap = m.caps[0]
254		- this.actor.send(cap, new Message({data: 'test'}))
	333	+ static functions (actor) {
	334	+ return {
	335	+ onCreation: funcRef => {
	336	+ actor.send(new Message({funcRef, funcArguments: ['test']}))
	337	+ }
	338	+ }
255	339	}
256	340
257	341	static get typeId () {
258	342	return 8
		@@ -262,9 +346,10 @@
262	346	const hypervisor = new Hypervisor(tree)
263	347	hypervisor.registerContainer(testVMContainerA)
264	348	hypervisor.registerContainer(testVMContainerB)
265	349
266		- await hypervisor.createActor(testVMContainerA.typeId, new Message())
	350	+ const {exports} = await hypervisor.createActor(testVMContainerA.typeId)
	351	+ await hypervisor.send(new Message({funcRef: exports[0]}))
267	352
268	353	const stateRoot = await hypervisor.createStateRoot()
269	354	t.deepEquals(stateRoot, expectedState, 'expected root!')
270	355	})
		@@ -279,38 +364,50 @@
279	364	db: db
280	365	})
281	366
282	367	class testVMContainerA extends BaseContainer {
283		- onCreation (m) {
284		- const message1 = new Message({
285		- data: 'first'
286		- })
287		- const message2 = new Message({
288		- data: 'second'
289		- })
290		- const message3 = new Message({
291		- data: 'third'
292		- })
293		- this.actor.send(m.caps[0], message1)
294		- this.actor.incrementTicks(1)
295		- this.actor.send(m.caps[0], message2)
296		- this.actor.incrementTicks(1)
297		- this.actor.send(m.caps[0], message3)
	368	+ static functions (actor) {
	369	+ return {
	370	+ onCreation: funcRef => {
	371	+ const message1 = new Message({
	372	+ funcArguments: ['first'],
	373	+ funcRef
	374	+ })
	375	+ const message2 = new Message({
	376	+ funcArguments: ['second'],
	377	+ funcRef
	378	+ })
	379	+ const message3 = new Message({
	380	+ funcArguments: ['third'],
	381	+ funcRef
	382	+ })
	383	+ actor.send(message1)
	384	+ actor.incrementTicks(1)
	385	+ actor.send(message2)
	386	+ actor.incrementTicks(1)
	387	+ actor.send(message3)
	388	+ }
	389	+ }
298	390	}
299	391	}
300	392
301	393	let recMsg = 0
302	394
303	395	class testVMContainerB extends BaseContainer {
304		- onMessage (m) {
305		- if (recMsg === 0) {
306		- t.equal(m.data, 'first', 'should recive fist message')
307		- } else if (recMsg === 1) {
308		- t.equal(m.data, 'second', 'should recive second message')
309		- } else {
310		- t.equal(m.data, 'third', 'should recive third message')
	396	+ static functions (actor) {
	397	+ return {
	398	+ onMessage: data => {
	399	+ actor.incrementTicks(1)
	400	+ if (recMsg === 0) {
	401	+ t.equal(data, 'first', 'should recive fist message')
	402	+ } else if (recMsg === 1) {
	403	+ t.equal(data, 'second', 'should recive second message')
	404	+ } else {
	405	+ t.equal(data, 'third', 'should recive third message')
	406	+ }
	407	+ recMsg++
	408	+ }
311	409	}
312		- recMsg++
313	410	}
314	411
315	412	static get typeId () {
316	413	return 8
		@@ -320,12 +417,15 @@
320	417	const hypervisor = new Hypervisor(tree)
321	418	hypervisor.registerContainer(testVMContainerA)
322	419	hypervisor.registerContainer(testVMContainerB)
323	420
324		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
325		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
326		- caps: [capB]
327		- }))
	421	+ const {exports: exportsB} = await hypervisor.createActor(testVMContainerB.typeId)
	422	+ const {exports: exportsA} = await hypervisor.createActor(testVMContainerA.typeId)
	423	+ const message = new Message({
	424	+ funcRef: exportsA[0],
	425	+ funcArguments: exportsB
	426	+ })
	427	+ hypervisor.send(message)
328	428
329	429	const stateRoot = await hypervisor.createStateRoot()
330	430	t.deepEquals(stateRoot, expectedState, 'expected root!')
331	431	})
		@@ -341,28 +441,38 @@
341	441	db: db
342	442	})
343	443
344	444	class testVMContainerA extends BaseContainer {
345		- onCreation (m) {
346		- message = new Message({
347		- data: m.data
348		- })
349		- this.actor.send(m.caps[0], message)
	445	+ static functions (actor) {
	446	+ return {
	447	+ onCreation: (funcRef, funcArguments) => {
	448	+ actor.incrementTicks(1)
	449	+ message = new Message({
	450	+ funcRef,
	451	+ funcArguments: [funcArguments]
	452	+ })
	453	+ return actor.send(message)
	454	+ }
	455	+ }
350	456	}
351	457	}
352	458
353	459	let recMsg = 0
354	460
355	461	class testVMContainerB extends BaseContainer {
356		- onMessage (m) {
357		- if (recMsg === 0) {
358		- t.equal(m.data, 'first', 'should recive fist message')
359		- } else if (recMsg === 1) {
360		- t.equal(m.data, 'second', 'should recive second message')
361		- } else {
362		- t.equal(m.data, 'third', 'should recive third message')
	462	+ static functions (actor) {
	463	+ return {
	464	+ onMessage: data => {
	465	+ if (recMsg === 0) {
	466	+ t.equal(data, 'first', 'should recive fist message')
	467	+ } else if (recMsg === 1) {
	468	+ t.equal(data, 'second', 'should recive second message')
	469	+ } else {
	470	+ t.equal(data, 'third', 'should recive third message')
	471	+ }
	472	+ recMsg++
	473	+ }
363	474	}
364		- recMsg++
365	475	}
366	476
367	477	static get typeId () {
368	478	return 8
		@@ -372,354 +482,93 @@
372	482	const hypervisor = new Hypervisor(tree)
373	483	hypervisor.registerContainer(testVMContainerA)
374	484	hypervisor.registerContainer(testVMContainerB)
375	485
376		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
377		- hypervisor.send(capB, new Message({
378		- data: 'first'
	486	+ let {exports: exportsB} = await hypervisor.createActor(testVMContainerB.typeId)
	487	+ hypervisor.send(new Message({
	488	+ funcRef: exportsB[0],
	489	+ funcArguments: ['first']
379	490	}))
380	491
381		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
382		- caps: [capB],
383		- data: 'second'
	492	+ const {exports: exportsA0} = await hypervisor.createActor(testVMContainerA.typeId)
	493	+
	494	+ hypervisor.send(new Message({
	495	+ funcRef: exportsA0[0],
	496	+ funcArguments: [exportsB[0], 'second']
384	497	}))
385	498
386		- await hypervisor.createActor(testVMContainerA.typeId, new Message({
387		- caps: [capB],
388		- data: 'third'
	499	+ const {exports: exportsA1} = await hypervisor.createActor(testVMContainerA.typeId)
	500	+ hypervisor.send(new Message({
	501	+ funcRef: exportsA1[0],
	502	+ funcArguments: [exportsB[0], 'third']
389	503	}))
390	504
391	505	const stateRoot = await hypervisor.createStateRoot()
392	506	t.deepEquals(stateRoot, expectedState, 'expected root!')
393	507	})
394	508
395		-tape('basic tagged caps', async t => {
396		- t.plan(4)
397		- const expectedState = {
398		- '/': Buffer.from('b8eb399087a990e30373e954b627a9512c9af40b', 'hex')
399		- }
400		-
	509	+tape('random', async t => {
	510	+ const numOfActors = 10
	511	+ const depth = 10
	512	+ const messageOrder = {}
	513	+ let numOfMsg = 0
401	514	const tree = new RadixTree({
402	515	db: db
403	516	})
404	517
405		- class testVMContainerA extends BaseContainer {
406		- async onMessage (m) {
407		- t.true(m, 'should recive first message')
408		- const rCap = this.actor.mintCap(1)
409		- const message = new Message({caps: [rCap]})
410		- this.actor.send(m.caps[0], message)
411		- const rMessage = await this.actor.inbox.nextTaggedMessage([1], 44)
412		- t.true(rMessage, 'should recive a response message')
413		- }
414		- }
415		-
416		- class testVMContainerB extends BaseContainer {
417		- onMessage (m) {
418		- t.true(m, 'should recive a message')
419		- this.actor.send(m.caps[0], new Message())
420		- }
421		-
422		- static get typeId () {
423		- return 8
424		- }
425		- }
426		-
427		- const hypervisor = new Hypervisor(tree)
428		- hypervisor.registerContainer(testVMContainerA)
429		- hypervisor.registerContainer(testVMContainerB)
430		-
431		- let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
432		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
433		-
434		- hypervisor.send(capA, new Message({caps: [capB]}))
435		-
436		- const stateRoot = await hypervisor.createStateRoot()
437		- t.deepEquals(stateRoot, expectedState, 'expected root!')
438		-})
439		-
440		-tape('trying to listen for caps more then once', async t => {
441		- t.plan(4)
442		- const expectedState = {
443		- '/': Buffer.from('b8eb399087a990e30373e954b627a9512c9af40b', 'hex')
444		- }
445		-
446		- const tree = new RadixTree({
447		- db: db
448		- })
449		-
450		- class testVMContainerA extends BaseContainer {
451		- async onMessage (m) {
452		- t.true(m, 'should recive first message')
453		- const message = new Message({data: 'first'})
454		- this.actor.send(m.caps[0], message)
455		- const promise = this.actor.inbox.nextTaggedMessage([1], 44)
456		- try {
457		- await this.actor.inbox.nextTaggedMessage([1], 44)
458		- } catch (e) {
459		- t.true(e, 'should error if waiting twice')
	518	+ class BenchmarkContainer extends BaseContainer {
	519	+ static functions (actor) {
	520	+ return {
	521	+ onMessage: function () {
	522	+ const refs = [...arguments]
	523	+ const ref = refs.pop()
	524	+ const last = messageOrder[actor.id.toString('hex')]
	525	+ const message = actor.currentMessage
	526	+ if (last) {
	527	+ t.ok(last <= message._fromTicks)
	528	+ }
	529	+ messageOrder[actor.id.toString('hex')] = message._fromTicks
	530	+ numOfMsg++
	531	+ actor.incrementTicks(10)
	532	+ if (ref) {
	533	+ return actor.send(new Message({
	534	+ funcRef: ref,
	535	+ funcArguments: refs
	536	+ }))
	537	+ }
	538	+ }
460	539	}
461		- return promise
462	540	}
463	541	}
464	542
465		- class testVMContainerB extends BaseContainer {
466		- onMessage (m) {
467		- t.true(m, 'should recive a message')
468		- }
469		-
470		- static get typeId () {
471		- return 8
472		- }
473		- }
474		-
475	543	const hypervisor = new Hypervisor(tree)
476		- hypervisor.registerContainer(testVMContainerA)
477		- hypervisor.registerContainer(testVMContainerB)
	544	+ hypervisor.registerContainer(BenchmarkContainer)
478	545
479		- let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
480		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
481		-
482		- await hypervisor.send(capA, new Message({caps: [capB]}))
483		-
484		- const stateRoot = await hypervisor.createStateRoot()
485		- t.deepEquals(stateRoot, expectedState, 'expected root!')
486		-})
487		-
488		-tape('multple messages to restore on waiting for tags', async t => {
489		- t.plan(6)
490		- const expectedState = {
491		- '/': Buffer.from('b2025e9430f0ce3a53767a36124fa622f782a38f', 'hex')
	546	+ const refernces = []
	547	+ let _numOfActors = numOfActors
	548	+ while (_numOfActors--) {
	549	+ const {exports} = await hypervisor.createActor(BenchmarkContainer.typeId)
	550	+ refernces.push(exports[0])
492	551	}
493		-
494		- const tree = new RadixTree({
495		- db: db
496		- })
497		-
498		- class testVMContainerA extends BaseContainer {
499		- async onMessage (m) {
500		- t.true(m, 'should recive first message')
501		- if (m.caps.length) {
502		- const cap1 = this.actor.mintCap(1)
503		- const cap2 = this.actor.mintCap(2)
504		- const message1 = new Message({
505		- data: 'first'
506		- })
507		- const message2 = new Message({
508		- data: 'second'
509		- })
510		- message1.caps.push(cap1)
511		- message2.caps.push(cap2)
512		- this.actor.send(m.caps[0], message1)
513		- this.actor.send(m.caps[1], message2)
514		- const rMessage = await this.actor.inbox.nextTaggedMessage([1, 2], 44)
515		- t.true(rMessage, 'should recive a response message')
516		- }
	552	+ _numOfActors = numOfActors
	553	+ let msgs = []
	554	+ while (_numOfActors--) {
	555	+ let _depth = depth
	556	+ const funcArguments = []
	557	+ while (_depth--) {
	558	+ const r = Math.floor(Math.random() * numOfActors)
	559	+ const ref = refernces[r]
	560	+ funcArguments.push(ref)
517	561	}
	562	+ const message = new Message({
	563	+ funcArguments,
	564	+ funcRef: refernces[_numOfActors]
	565	+ })
	566	+ msgs.push(message)
518	567	}
519	568
520		- class testVMContainerB extends BaseContainer {
521		- onMessage (m) {
522		- t.true(m, 'should recive a message')
523		- const cap = m.caps[0]
524		- this.actor.incrementTicks(1)
525		- this.actor.send(cap, new Message({data: m.data}))
526		- }
527		-
528		- static get typeId () {
529		- return 8
530		- }
531		- }
532		-
533		- const hypervisor = new Hypervisor(tree)
534		- hypervisor.registerContainer(testVMContainerA)
535		- hypervisor.registerContainer(testVMContainerB)
536		-
537		- let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
538		- let capB1 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
539		- let capB2 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
540		-
541		- hypervisor.send(capA, new Message({caps: [capB1, capB2]}))
542		-
543		- const stateRoot = await hypervisor.createStateRoot()
544		-
545		- t.deepEquals(stateRoot, expectedState, 'expected root!')
	569	+ msgs.forEach(msg => hypervisor.send(msg))
	570	+ // console.log('here', numOfMsg)
	571	+ await hypervisor.scheduler.wait(Infinity)
	572	+ t.equals(numOfMsg, 110)
	573	+ t.end()
546	574	})
547		-
548		-tape('multple messages to backup on waiting for tags', async t => {
549		- t.plan(6)
550		- const expectedState = {
551		- '/': Buffer.from('b2025e9430f0ce3a53767a36124fa622f782a38f', 'hex')
552		- }
553		-
554		- const tree = new RadixTree({
555		- db: db
556		- })
557		-
558		- class testVMContainerA extends BaseContainer {
559		- async onMessage (m) {
560		- t.true(m, 'should recive first message')
561		- if (m.caps.length) {
562		- const cap1 = this.actor.mintCap(1)
563		- const cap2 = this.actor.mintCap(2)
564		- const message1 = new Message({
565		- data: 'first'
566		- })
567		- const message2 = new Message({
568		- data: 'second'
569		- })
570		- message1.caps.push(cap1)
571		- message2.caps.push(cap2)
572		- this.actor.send(m.caps[0], message1)
573		- this.actor.send(m.caps[1], message2)
574		- const rMessage = await this.actor.inbox.nextTaggedMessage([1, 2], 44)
575		- t.true(rMessage, 'should recive a response message')
576		- }
577		- }
578		- }
579		-
580		- class testVMContainerB extends BaseContainer {
581		- async onMessage (m) {
582		- t.true(m, 'should recive a message')
583		- const cap = m.caps[0]
584		- this.actor.incrementTicks(1)
585		- this.actor.send(cap, new Message({data: m.data}))
586		- }
587		-
588		- static get typeId () {
589		- return 8
590		- }
591		- }
592		-
593		- const hypervisor = new Hypervisor(tree)
594		- hypervisor.registerContainer(testVMContainerA)
595		- hypervisor.registerContainer(testVMContainerB)
596		-
597		- let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
598		- let capB1 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
599		- let capB2 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
600		-
601		- hypervisor.send(capA, new Message({caps: [capB1, capB2]}))
602		-
603		- const stateRoot = await hypervisor.createStateRoot()
604		- t.deepEquals(stateRoot, expectedState, 'expected root!')
605		-})
606		-
607		-tape('multple messages, but single tag', async t => {
608		- t.plan(6)
609		- const expectedState = {
610		- '/': Buffer.from('b2025e9430f0ce3a53767a36124fa622f782a38f', 'hex')
611		- }
612		-
613		- const tree = new RadixTree({
614		- db: db
615		- })
616		-
617		- class testVMContainerA extends BaseContainer {
618		- async onMessage (m) {
619		- t.true(m, 'should recive first message')
620		- if (m.caps.length) {
621		- const cap1 = this.actor.mintCap(1)
622		- const cap2 = this.actor.mintCap(2)
623		- const message1 = new Message({
624		- data: 'first'
625		- })
626		- const message2 = new Message({
627		- data: 'second'
628		- })
629		- message1.caps.push(cap1)
630		- message2.caps.push(cap2)
631		- await this.actor.send(m.caps[0], message1)
632		- await this.actor.send(m.caps[1], message2)
633		- const rMessage = await this.actor.inbox.nextTaggedMessage([2], 44)
634		- t.true(rMessage, 'should recive a response message')
635		- }
636		- }
637		- }
638		-
639		- class testVMContainerB extends BaseContainer {
640		- async onMessage (m) {
641		- t.true(m, 'should recive a message')
642		- const cap = m.caps[0]
643		- this.actor.incrementTicks(1)
644		- this.actor.send(cap, new Message({data: m.data}))
645		- }
646		-
647		- static get typeId () {
648		- return 8
649		- }
650		- }
651		-
652		- const hypervisor = new Hypervisor(tree)
653		- hypervisor.registerContainer(testVMContainerA)
654		- hypervisor.registerContainer(testVMContainerB)
655		-
656		- let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
657		- let capB1 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
658		- let capB2 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
659		-
660		- hypervisor.send(capA, new Message({caps: [capB1, capB2]}))
661		-
662		- const stateRoot = await hypervisor.createStateRoot()
663		- t.deepEquals(stateRoot, expectedState, 'expected root!')
664		-})
665		-
666		-tape('deadlock test', async t => {
667		- t.plan(7)
668		- const expectedState = {
669		- '/': Buffer.from('54f55756d0255d849e6878cc706f4c1565396e5c', 'hex')
670		- }
671		-
672		- const tree = new RadixTree({
673		- db: db
674		- })
675		-
676		- class testVMContainerA extends BaseContainer {
677		- async onMessage (m) {
678		- t.true(m, 'should recive first message 1')
679		- const rMessage = await this.actor.inbox.nextTaggedMessage([1], 50)
680		- t.equals(rMessage, undefined, 'should recive a response message 1')
681		- }
682		- }
683		-
684		- class testVMContainerB extends BaseContainer {
685		- async onMessage (m) {
686		- t.true(m, 'should recive first message 2')
687		- this.actor.incrementTicks(47)
688		- const rMessage = await this.actor.inbox.nextTaggedMessage([1], 1)
689		- t.equals(rMessage, undefined, 'should recive a response message 2')
690		- }
691		-
692		- static get typeId () {
693		- return 8
694		- }
695		- }
696		-
697		- class testVMContainerC extends BaseContainer {
698		- async onMessage (m) {
699		- t.true(m, 'should recive first message 3')
700		- this.actor.incrementTicks(45)
701		- const rMessage = await this.actor.inbox.nextTaggedMessage([1], 1)
702		- t.equals(rMessage, undefined, 'should recive a response message 3')
703		- }
704		-
705		- static get typeId () {
706		- return 7
707		- }
708		- }
709		-
710		- const hypervisor = new Hypervisor(tree)
711		- hypervisor.registerContainer(testVMContainerA)
712		- hypervisor.registerContainer(testVMContainerB)
713		- hypervisor.registerContainer(testVMContainerC)
714		-
715		- let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
716		- let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
717		- let capC = await hypervisor.createActor(testVMContainerC.typeId, new Message())
718		-
719		- hypervisor.send(capA, new Message())
720		- hypervisor.send(capB, new Message())
721		- hypervisor.send(capC, new Message())
722		-
723		- const stateRoot = await hypervisor.createStateRoot()
724		- t.deepEquals(stateRoot, expectedState, 'expected root!')
725		-})

message.jsView
		@@ -1,0 +1,39 @@
	1	+const EventEmitter = require('events')
	2	+
	3	+/**
	4	+ * This implements Messages for Primea
	5	+ * @module primea-message
	6	+ */
	7	+module.exports = class Message extends EventEmitter {
	8	+ /**
	9	+ * @param {Object} opts
	10	+ * @param {ArrayBuffer} opts.data - the payload of the message
	11	+ * @param {Array<Object>} opts.caps - an array of capabilities to send in the message
	12	+ */
	13	+ constructor (opts) {
	14	+ super()
	15	+ const defaults = this.constructor.defaults
	16	+ this._opts = Object.assign(defaults, opts)
	17	+ Object.keys(this._opts).forEach(key => {
	18	+ Object.defineProperty(this, key, {
	19	+ get: function () {
	20	+ return this._opts[key]
	21	+ },
	22	+ set: function (y) {
	23	+ this._opts[key] = y
	24	+ }
	25	+ })
	26	+ })
	27	+ }
	28	+
	29	+ static get defaults () {
	30	+ return {
	31	+ ticks: 0,
	32	+ funcRef: null,
	33	+ funcArguments: [],
	34	+ funcParameters: [],
	35	+ _fromId: Buffer.alloc(20),
	36	+ _fromTicks: 0
	37	+ }
	38	+ }
	39	+}

Built with git-ssb-web

wanderer🌟 / js-primea-hypervisor

Commit 3f8c23e36f6d90d0c86b778fb27c24c5aa57c8a1

rewrite

Files changed