perlin-network / life Goto Github PK

package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello World")
}

panic: unexpected EOF

goroutine 1 [running]:
main.main()
	/Users/gsingh/tmp/life/main.go:81 +0x72c

# github.com/perlin-network/life/compiler
src/github.com/perlin-network/life/compiler/module.go:115:8: e.Kind undefined (type *wasm.ImportEntry has no field or method Kind)

ptr := int(uint32(vm.GetCurrentFrame().Locals[0]))
msgLen := int(uint32(vm.Memory[ptr]))
msg := vm.Memory[(ptr + 4):(ptr + 4 + 2*msgLen)]
fmt.Println(ptr)`

export function app_main():string{
	let a = "Hello";
	r.consoleLog(a);
	return '0';
}

export function app_main():string{
		r.consoleLog('World');
		return '0';
}

export function app_main():string{
		let a = 'World';
		r.consoleLog("Hello"+a);
		return '0';
}

		case opcodes.AddGas:
			delta := LE.Uint64(frame.Code[frame.IP : frame.IP+8])

#[no_mangle]
pub extern "C" fn sum(n: u64) -> u64 {
        let mut res = 0;
        for x in 0..n {
                res += x;
        }
        return res;
}

#[no_mangle]
pub extern "C" fn app_main() -> u64 {
        sum(1_000_000)
}

extern void get(char *);

int add() {
	char  aa[100];
	get(aa);
  return 0;
}

$ ./life bench/cases/fib_recursive/target/wasm32-unknown-unknown/release/fib_recursive.wasm 
panic: input too large

goroutine 1 [running]:
main.main()
        /Users/jehan/life/main.go:86 +0xc29

➜  go get
go: finding github.com/perlin-network/life/exec latest
go: finding github.com/perlin-network/life latest
go: finding github.com/go-interpreter/wagon v0.0.0
go: github.com/go-interpreter/[email protected]: unknown revision v0.0.0
go: error loading module requirements

function invoke_ii(index,a1) {
  var sp = stackSave();
  try {
    return Module["dynCall_ii"](index,a1);
  } catch(e) {
    stackRestore(sp);
    if (typeof e !== 'number' && e !== 'longjmp') throw e;
    Module["setThrew"](1, 0);
  }
}

func GetExport(vm *exec.VirtualMachine,name string) int64{
	entryID, ok := vm.GetGlobalExport(name)
	if ok {
		fmt.Printf("Entry GlobalExport %s not found; starting from 0.\n", name)
		entryID = 0
	}
	ret, err := vm.Run(entryID)

	if err != nil {
		vm.PrintStackTrace()
		panic(err)
	}
	return ret
}

#include <stdio.h>
#include <string.h>
#include <cstdlib>
extern "C" {
extern void logi(int);
extern void logs(char *);
extern void logl(long);
}
int main() {
    int a[3];
    a[0]=134;
    a[1]=13;
    a[2]=52;
    for (const auto &item : a)
    {
        logi(item);
    }
    return 0;
}

(module
 (type $FUNCSIG$vi (func (param i32)))
 (import "env" "logi" (func $logi (param i32)))
 (table 0 anyfunc)
 (memory $0 1)
 (export "memory" (memory $0))
 (export "main" (func $main))
 (func $main (; 1 ;) (result i32)
  (local $0 i32)
  (local $1 i32)
  (local $2 i32)
  (i32.store offset=4
   (i32.const 0)
   (tee_local $2
    (i32.sub
     (i32.load offset=4
      (i32.const 0)
     )
     (i32.const 16)
    )
   )
  )
  (i32.store offset=12
   (get_local $2)
   (i32.const 52)
  )
  (i64.store offset=4 align=4
   (get_local $2)
   (i64.const 55834574982)
  )
  (call $logi
   (i32.const 134)
  )
  (set_local $0
   (i32.add
    (i32.add
     (get_local $2)
     (i32.const 4)
    )
    (i32.const 4)
   )
  )
  (set_local $1
   (i32.const 0)
  )
  (loop $label$0
   (call $logi
    (i32.load
     (i32.add
      (get_local $0)
      (get_local $1)
     )
    )
   )
   (br_if $label$0
    (i32.ne
     (tee_local $1
      (i32.add
       (get_local $1)
       (i32.const 4)
      )
     )
     (i32.const 8)
    )
   )
  )
  (i32.store offset=4
   (i32.const 0)
   (i32.add
    (get_local $2)
    (i32.const 16)
   )
  )
  (i32.const 0)
 )
)

=== RUN   TestWasmRun
--- Begin stack trace ---
<0> [1] 
--- End stack trace ---
--- FAIL: TestWasmRun (0.00s)
panic: runtime error: slice bounds out of range [recovered]
	panic: runtime error: slice bounds out of range

λ ~/GoPath/src/github.com/perlin-network/life/ master vgo mod -vendor
go: finding github.com/losfair/wagon v0.0.0-20180807163237-f6497f251c75
go: github.com/losfair/[email protected]: unknown revision f6497f251c75d3d2ea31bdbc05b636f5d4d39221
go: error loading module requirements

matt@ubuntu:~/web/life$ go build
go: finding github.com/go-interpreter/wagon v0.0.0
build github.com/perlin-network/life: cannot find module for path bytes

type GasPolicy interface {
	GetCost(key Instr) int64
}

jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ export PATH=/usr/local/go1.11.1/bin:$PATH
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ go version
go version go1.11.1 darwin/amd64
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ GOARCH=wasm GOOS=js go build -o lib.wasm m.go
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ ls -alFtr|tail
drwxrwxr-x   3 jaten  staff       96 Oct 22 22:39 spec/
drwxrwxr-x  14 jaten  staff      448 Oct 22 22:39 tests/
drwxrwxr-x   3 jaten  staff       96 Oct 22 22:39 utils/
drwxrwxr-x  13 jaten  staff      416 Oct 22 22:39 .git/
-rw-rw-r--   1 jaten  staff      350 Oct 22 22:40 go.sum
drwxrwxr-x   4 jaten  staff      128 Oct 22 22:40 vendor/
-rwxrwxr-x   1 jaten  staff  3496456 Oct 22 22:40 test_runner*
-rw-rw-r--   1 jaten  staff      177 Oct 22 22:44 m.go
-rwxrwxr-x   1 jaten  staff  2532371 Oct 22 22:44 lib.wasm*
drwxrwxr-x  22 jaten  staff      704 Oct 22 22:44 ./
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ life ./lib.wasm
Resolve func: go debug
panic: unknown module: go

goroutine 1 [running]:
main.main()
	/Users/jaten/go/src/github.com/perlin-network/life/main.go:78 +0x63d
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ cat m.go
package main

import (
	"fmt"
	"time"
)

func main() {
	t0 := time.Now()
	a := 0
	for i := 0; i < 10000000; i++ {
		a++
	}
	fmt.Printf("a = %v, elap=%v\n", a, time.Since(t0))
}
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ go run m.go # positive control
a = 10000000, elap=2.941357ms
jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ git log|head
commit 4e2637791edc5716293a29710531e36d39da4d5c
Merge: 1eb3d14 6525bd2
Author: Heyang Zhou <[email protected]>
Date:   Fri Oct 12 11:18:30 2018 +0800

    Merge pull request #38 from perlin-network/return-on-gas-limit
    
    Allow normal return instead of error when gas limit is exceeded.

jaten@jatens-MacBook-Pro ~/go/src/github.com/perlin-network/life (master) $ 

connecto/input/src/github.com/connecto/lifecontractone/vendor/github.com/perlin-network/life/compiler/module.go:147:31: too many arguments in call to disasm.Disassemble
	have (wasm.Function, *wasm.Module)
	want ([]byte)
connecto/input/src/github.com/connecto/lifecontractone/vendor/github.com/perlin-network/life/compiler/module.go:151:39: cannot use d (type []disasm.Instr) as type *disasm.Disassembly in argument to NewSSAFunctionCompiler
connecto/input/src/github.com/connecto/lifecontractone/vendor/github.com/perlin-network/life/compiler/module.go:223:31: too many arguments in call to disasm.Disassemble
	have (wasm.Function, *wasm.Module)
	want ([]byte)
connecto/input/src/github.com/connecto/lifecontractone/vendor/github.com/perlin-network/life/compiler/module.go:227:39: cannot use d (type []disasm.Instr) as type *disasm.Disassembly in argument to NewSSAFunctionCompiler

// Resolver defines imports for WebAssembly modules ran in Life.
type Resolver struct {
	tempRet0 int64
}

// ResolveFunc defines a set of import functions that may be called within a WebAssembly module.
func (r *Resolver) ResolveFunc(module, field string) exec.FunctionImport {
	fmt.Printf("Resolve func: %s %s\n", module, field)
	switch module {
	case "env":
		switch field {
		case "__life_log":
			return func(vm *exec.VirtualMachine) int64 {
				ptr := int(uint32(vm.GetCurrentFrame().Locals[0]))
				msgLen := int(uint32(vm.GetCurrentFrame().Locals[1]))
				msg := vm.Memory[ptr : ptr+msgLen]
				fmt.Printf("[app] %s\n", string(msg))
				return 0
			}
		default:
			panic(fmt.Errorf("unknown field: %s", field))
		}
	default:
		panic(fmt.Errorf("unknown module: %s", module))
	}
}

// ResolveGlobal defines a set of global variables for use within a WebAssembly module.
func (r *Resolver) ResolveGlobal(module, field string) int64 {
	fmt.Printf("Resolve global: %s %s\n", module, field)
	switch module {
	case "env":
		switch field {
		case "__life_magic":
			return 424
		default:
			panic(fmt.Errorf("unknown field: %s", field))
		}
	default:
		panic(fmt.Errorf("unknown module: %s", module))
	}
}

// query callback representing the query of a chaincode
func main()  {

	wasmbytes, _ := getWasm(A)
	entryFunctionFlag := flag.String("entry", "funcToInvoke", "entry function name")
	noFloatingPointFlag := flag.Bool("no-fp", false, "disable floating point")
	flag.Parse()


	validator, err := wasm_validation.NewValidator()
	if err != nil {
		panic(err)
	}
	err = validator.ValidateWasm(Chaincodebytes)
	if err != nil {
		panic(err)
	}

	// Instantiate a new WebAssembly VM with a few resolved imports.
	vm, err := exec.NewVirtualMachine(Chaincodebytes, exec.VMConfig{
		DefaultMemoryPages:   128,
		DefaultTableSize:     65536,
		DisableFloatingPoint: *noFloatingPointFlag,
	}, new(Resolver), nil)

	if err != nil {
		panic(err)
	}

	// Get the function ID of the entry function to be executed.
	entryID, ok := vm.GetFunctionExport(*entryFunctionFlag)
	if !ok {
		fmt.Printf("Entry function %s not found; starting from 0.\n", *entryFunctionFlag)
		entryID = 0
	}

	start := time.Now()

	// Run the WebAssembly module's entry function.
	result, err := vm.Run(entryID)
	if err != nil {
		vm.PrintStackTrace()
		panic(err)
	}
	end := time.Now()

	fmt.Printf("return value = %d, duration = %v\n", result, end.Sub(start))

	fmt.Printf("Query Response:%s\n", result)
}

module github.com/ansermino/wasm-test

replace github.com/go-interpreter/wagon v0.0.0 => github.com/perlin-network/wagon v0.3.1-0.20180825141017-f8cb99b55a39

require (
	github.com/go-interpreter/wagon v0.4.0 // indirect
	github.com/perlin-network/life v0.0.0-20190402092845-c30697b41680
	google.golang.org/appengine v1.5.0 // indirect
)

# github.com/perlin-network/life/compiler
../../../../pkg/mod/github.com/perlin-network/[email protected]/compiler/module.go:147:31: too many arguments in call to disasm.Disassemble
        have (wasm.Function, *wasm.Module)
        want ([]byte)
../../../../pkg/mod/github.com/perlin-network/[email protected]/compiler/module.go:151:39: cannot use d (type []disasm.Instr) as type *disasm.Disassembly in argument to NewSSAFunctionCompiler
../../../../pkg/mod/github.com/perlin-network/[email protected]/compiler/module.go:223:31: too many arguments in call to disasm.Disassemble
        have (wasm.Function, *wasm.Module)
        want ([]byte)
../../../../pkg/mod/github.com/perlin-network/[email protected]/compiler/module.go:227:39: cannot use d (type []disasm.Instr) as type *disasm.Disassembly in argument to NewSSAFunctionCompiler

// Execute starts the virtual machines main instruction processing loop.
// This function may return at any point and is guaranteed to return
// at least once every 10000 instructions. Caller is responsible for
// detecting VM status in a loop.