webassembly / meetings Goto Github PK

Here are a list of the current proposals. Which of these shall we discuss at the upcoming in-person CG meeting at TPAC?

• Threads (champion @binji - phase 1)
  • Updates on memory model and spec (@conrad-watt and @rossberg)
  • Race between memory.grow and access
• Garbage Collection (champion @rossberg - phase 1)
• Bulk memory operations (champion @binji - phase 1)
• ECMAScript module integration (champion @linclark - phase 1)
• Tail Call (champion @rossberg - phase 1)
• Multi-value (champion @rossberg - phase 3)
  • Move to stage 4? (blocked on implementation)
• Reference types (champion @rossberg - phase 3)
  • Move to stage 4? (blocked on implementation)
• Host bindings (champion @lukewagner - phase 1)
  • Recap problem statement: direct calls to any Web IDL methods/accessors from wasm
  • Recap developments since TPAC last year: extraction of the Reference Types proposal
  • Short browser update on any browser implementation progress toward Reference Types
  • Given Reference Types, what's left for Host Bindings to do?
    • The following are still missing when calling Web IDL:
      • Pass/receive a non-undefined receiver
      • Call as a constructor
      • Opt into unsigned interpretation of i32/i64 when converting to Number/BigInt
      • Callbacks: function reference types + func.bind (+ WeakRefs)
    • With Reference Types factored out into the core spec, consider renaming to "Web IDL Bindings"?
  • Observation: the real value prop to use any of this (from browser POV) is fast Web IDL calls
  • So, proposal: let's define a milestone that combines Reference Types + Web IDL Bindings MVP
  • Some WebGL/Emscripten glue code can move into WASM bytecode; this will help fast Web IDL calls
  • How would this look in the source language?
    • Short recap of Rust wasm-bindgen
    • How would this look in other languages? Is there an opportunity to share/regularize backend tools?
• JavaScript BigInt to WebAssembly i64 integration (champion @littledan - phase 2)
• Web Content Security Policy (champion none - phase 0)
  • How does CSP affect postMessaging of Modules
• Non-trapping float-to-int conversions (champion @sunfishcode - phase 4)
• Sign-extension operators (champion @binji - phase 4)
• Type Reflection for WebAssembly JavaScript API (champion @tschneidereit - phase 1)
• Unmanaged closures (champion @erights - phase 0)
• Custom Annotation Syntax in the Text Format (champion @rossberg - phase 1)
• Fixed-width SIMD (champion none - phase 1)
• Exception handling (champion @aheejin - phase 1)

I'm guessing that we won't need any discussion on the phase 4 proposals.

If you are a champion of one of these proposals, please respond whether you are planning to go to this CG meeting to discuss your proposal.

I believe we will need some new champions for some of these proposals, so if you are a current champion and would no longer like to be, please respond here too.

Multiple return values and generalised block types pick operator: "Luke to follow up on the impact for emscripten."

• LW: Talked to Alon, and he said that it would not be easy to perform measurements for this because it isn’t really AST.
• DS: Not easy for wasm backend either.
• BT: We have some amount of implementation in v8.
• JF: We were trying to figure out whether it was useful for just functions or block types.
• BT: We have both.
• JF: This item is about producers. But DS, you can work on this?
• DS: Yes.

Action item: Derek to come back on this, with data from the LLVM wasm backend. Andreas implemented it in V8, so will try it out there.

From CG-02-21:
Brad to ping tooling people, as well as Brotli people.

On CG-01-26 we discussed Contribution policies and repos for tools targeting WebAssembly. @dschuff presented: slides.

AI: Brad to put this on the WG agenda. JF to bring back results to next CG meeting.

Action item: (not done from last meeting) JZ / BN to gather another similar integer benchmark.

TPAC 2019 is coming up on the 16–20 of September. Starting this as a coordination issue for folks that plan to attend TPAC. In previous meetings when we discussed TPAC, there was consensus on not having a CG meeting this time, but interest in using this as an opportunity to interact with other community/working groups. There was also interest in hosting a WebAssembly AMA as was done last year. Some notes -

• The WebAssembly CG does not have a reserved room at TPAC this time, but there is a room set aside for the Wasm WG on Thursday, 9/19 that we may be able to use. If folks going would like a dedicated room, please reply to this and I can follow up to see if this can be arranged.
• The plenary day (9/18) may be a good time to host the Wasm AMA

Even if you don't intend to attend TPAC in person, please take a look at the schedule and respond with issues that may be useful to discuss there.

At the Fastly in-person meeting discussion of GC we took the following action item:

Action item: Andreas to list success criteria / target users for each step of the split GC proposal.

The PR WebAssembly/mutable-global#13 incompatibly changes the JS API in the mutable-globals spec, to wit, a value that was previously in the globals descriptor is now passed as a second parameter to the constructor. I don't really object to the technical matter here, but to how this change was made to a spec that has been stable for some time. The change is mentioned twice, very briefly, in the meeting notes and appears to be a fallout from discussion about reference types; there was no poll re making the change (unlike, say, changing the default value for FP globals); the PR itself contains no justification for its existence, not even a reference to the minutes or to an Issue.

Not everyone working on wasm can attend all the CG meetings, sadly, but that seems immaterial. Changes of this kind to fairly stable features need better supporting materials and need to be backed by a poll.

Action item: Brad to ask some Google folk to do a WPT 1-way sync, and / or come back to the group if they won’t.

What topics shall we cover at the meeting? Comment below and I'll add/remove them from this list.

All times are currently estimates. If you think a topic needs more time, please comment below.

• WebIDL bindings (1-2 hrs)
• Garbage Collection (1 hr?)
  • Split typed imports and exports out from GC proposal
• Threads (1 hr)
  • Add fence instruction (½ hr)
• ECMAScript Module Integration (1 hr)
  • Exported function to call after instantiation (see WebAssembly/design#1160 (comment))
• Exception Handling (½-1 hr)
• JS/web adjacent topics: (1 hr)
  • WeakRefs, Atomics.waitAsync, built-in modules, import-maps, WebIDL, get-originals
• SIMD (½-1 hr)
• Reference Types (½-1 hr)
• Function references (½-1 hr)
• Bulk Memory (½ hr)
  • Passive element segment encoding
• Collaborative benchmark suite (½ hr)
• Multi Value (update) (¼-½ hr)
  • Poll: phase 4
• Tail Calls (¼ hr)
• Debugging Subgroup topics? (?)
  • Separable debug info
  • Source maps
• C/C++ API (drop?)
• WASI topics?

It seems that I just missed a WebAssembly CG meeting today at 4pm-5pm UTC, in my calendar the event is tomorrow at 8 am GMT+2.

I don't know if i'm the only one but the recurring event seems to be in a wrong timezone.

Action item: Intel folks to see in their traces how the instructions are used (variable or constants as inputs).

During the 7/9 video call, the CG consented to advancing my extended name section proposal to phase 1.

Can somebody with access please create a repo for it under the WebAssembly org?

I'm filing this here because this is the repo in which the 'process' document lives.

Do we have a page that tracks proposals and the stage that each proposal is at?

I was going to propose that the CG meeting this week advance the sign extension opcodes proposal but to my distress I'm unable to find out even what stage it is at now, much less whether we are tracking in a systematic way whether any entrance criteria are met for the next stage.

For TC39 it seems to be the case that something is a proposal iff it is on the proposals list, and that list is relatively easy to find. If we have such a thing for Wasm we should make it easier to find it. If we don't have one we should make one.

@bterlson has a cool tool that he uses to moderate TC39 discussions, where people can add themselves to a queue during the meeting to ask questions, etc. We should consider using it for in-person WebAssembly meetings.

AI from the CG-01-26 meeting.

Action item: Luke to work with Dan E on JS embedding tests, and report back in the next meeting.

Action item: Brad to sync with his PM to own WebAssembly.org

Action item: (not done from last meeting) JZ / BN to come back with concrete proposal of what the narrowing/widening, min/max operations should look like.

Action item: Brad to make forward progress on the tools and come back with numbers in-browser. Microsoft and Mozilla to measure as well.

Action item: Brad to explore instantiateStreaming + promise imports more, and talk to module loader API folks (Domenic?). Mark Miller to help Brad.

During the SIMD discussion at Fastly we took the following action item:

Action Item: Dan Gohman to do research into the usefulness of 8-bit multiply.

From CG-02-21: Brad to set up joint meeting. Anyone interested should reach out to Brad.

Action item: Heejin to come back with a full implementation of the toolchain and VM, and report on resulting size and performance. Which implementation approach is taken is left up to Heejin. Derek mentions that they may explore a few alternatives and quantify their cost.

From CG-01-26:

Some of the tests import a module called spectest and import a function called print which is overloaded by the embedder. Each import re-imports it with a different signature, but that’s weird because WebAssembly itself doesn’t have overloading. That way you could implement the spectest module in WebAssembly. Same with kinds: a global and function could have the same name.

• Andreas: we could remove it from core tests, but we should still make sure that it validates.
• Luke: I like the principle of being able to implement standard library in WebAssembly.
• Andreas: I would propose removing the print function from the spec tests. We should use assertions instead. It’s no longer relevant. We’ll still test imports, but it doesn’t have to be print.

POLL: unanimous consent to remove polymorphic imports.

AI: Dan to update spec tests to not be polymorphic.

Action item: James to post numbers from Vincent, measured with ARM A53 / A72.

• BN: Will this be used in LLVM?
• DS: LLVM has this and uses it for haskell, maybe others.
• BN: Natural tail calls?
• DS: Front end will stick an attribute on the function, then backend can choose what to do.
• MH: If it’s for optimization, we don’t have to spec at all.
• DG: Current spec you’re not allowed to do that at all.
• JF: We want to design something that works well for C/C++, and the main holdback for MS is fewer params to more params, that’s a problem.
• BT: The feature is to support proper tail calls, if there is a limitation then it should be one that is easy to lift.
• JF: We want to have something simple and useful to try out, then see if we can do more. Without involvement with people from other languages, we are just guessing.
• BT: My impression overall, the people in this room have driven the design. Only now people are showing up to take a look.
• BN: We were talking about having an outreach event in SF for people interested in wasm from a user point of view.
• JF: TPAC is specifically for web platform
• BT: We have survivor bias, we see the things that are successful
• LW: Once we have GC types, we’ll see more folks who are interested in tail calls.
• MH: Talking with C# team, they can’t use params have to put everything in linear memory.
• BM: People would like to get better performance than that. If you’re already using a shadow stack, might as well do params too.
• JF: We have two action items, Brad to sync with Rossberg, Brad also to follow up with measurements on toolchain end
• DS: Need data for: what are the instances of tail call optimizations, and what are the instances of required tail calls.
• BN: Have folks who are potential users of the format, but won’t necessarily come to the CG.

Action item: JF to figure out how to reach out to potential producers of the format who don’t want to come to CG meetings but would be good to talk to.

At the 2018-04-03 meeting Dan presented his findings. After a long discussion we concluded:

AI: Dan to come back with update next meeting.

"Google toolchain folks: Gather data on where tail call would be used, what it would look like."

Brad to make sure someone measures interesting corpus for C++ code, to see how tail call could be used and if there are more / fewer / same number of parameters.

As discussed on 12/12, AI for @eholk

It will be great to have one official place for general WebAssembly discussions. It feels like IRC is not very popular among developers nowadays (it's pretty popular comparing to different slack workspaces though, some numbers below). Slack requires invites to join so it's not very good option too (though, different Slack workspaces could create shared channel for wasm-related discussions). I'm not sure what could be the most optimal application / website for CG discussions, so I propose to discuss this at some of upcoming CG meetings.

cc'ing people who may be interested in this as well @xtuc @dcodeIO @MaxGraey @TheLarkInn @kripken

Population of WebAssembly channels I'm aware of:

• irc.w3c.org #webassembly channel - 87 members
• Mozilla irc #wasm channel - 70 members
• webpack slack #webassembly channel (about wasm bundling in webpack) - 38 members
• Babel slack #webassembly channel (about webassemblyjs and other tools) - 16 members
• The whole webassemblydevelopers.slack.com (has various channels) - 35 members
• The whole AssemblyScript.slack.com (about AssemblyScript) - 20 members
• Russian-speaking https://t.me/webassembly_ru Telegram channel - ~500 members

cc @binji @littledan

In https://github.com/WebAssembly/meetings/blob/945dab8924f81131300c7e193c901810ed1edd4d/2018/TPAC.md, the dates are:

• Thursday 25th - 10:00am to 5:00pm (GC)
• Friday 26th - 10:00am to 5:00pm (GC)

On their website (https://www.w3.org/2018/10/TPAC/schedule.html), the dates are:

• Tuesday 23th - 10:30 - 12:30 (GC)
• Thursday 25th - entire day? (WG)
• Friday 26th - entire day? (WG)

One person from TPAC/W3C confirmed those dates to me. If we all agree on these dates, I can submit a PR to correct the TPAC.md file.

Also personnally I'd like to participate in the meetings (espically for ESM if scheduled). Given those dates and being only in the GC, spending my time to be in Lyon for 2 hours seems a bit "overkilled" to me. I suppose that very few peoples from GC will show up.

Action item: Andreas to explore making “tailcall” part of function signatures, and document why he thinks this has bad implications. Michael / Luke to synchronize on why it would be useful to them.

We discussed this in the December 11 meeting.

Should we change the entry requirement for phase 4 to allow for two non-web implementations? @rossberg suggested replacing "Web VMs" with "production VMs"

I assume that the 'zoom' link (https://zoom.us/j/959114359) is correct for the F2F; but it would be nice to have that confirmed on the agenda

CG and WG videoconference meetings are currently hosted with Google Hangouts. When I attempt to attend meetings with Firefox, I'm presented with a page which says:

For some web browsers, including Firefox, Hangouts uses a plugin to enable video and phone calls.

Firefox is ending support for plugins, so Hangouts won’t be able to support video and phone calls in Firefox until Hangouts is updated to resolve the problem. Google is working on a solution that will be available as soon as possible.

To reflect the spirit of cross-browser collaboration and Web standards, the WebAssembly videoconference meetings should support WebRTC-capable browsers.

WebAssembly is finding a home within blockchains.

As a non-web platform, blockchains have distinct requirements. We have compiled notes from projects across the space (Ethereum, Parity, Dfinity, and Truebit), and will use this session to give an overview of approaches and challenges to the wider community. Referenced in CG-04.

We will discuss the following points:

• An overview of the blockchain VM:

  • A coordination layer between the WebAssembly VM and blockchain state.

• The blockchain VM needs to be deterministic (for nodes to reach consensus within the distributed network):

  • Resource limits: stack depth & memory.
  • Floating point.
  • Other sources of indeterminism: instantiation of a module

• Blockchains meter resource utilization:

  • The mechanics of metering: insert metering instructions per branch after verification.
  • Time: metering for instructions
  • Space: metering for memory

• Typed traps

  • To enable symbolic execution and static analysis tools.

• Imports

  • Accessing the memory: a spec for non-browser-based VMs.
  • Async / promises.
  • Having a WebAssembly standard library which defines operating system syscall.

• Instrumentation:

  • Two parts: 1) what to collect, 2) how to collect it.
  • Introducing ways to inspect the stack.

• Backward compatibility

  • Good: WASM binaries starts with a distinct flag.
  • Existing projects: JULIA, evm2wasm.

• New WASM developments which will be helpful:

  • Multi-values
  • References types
  • Annotations
  • Capabilities

• New WASM developments which might not be helpful (due to non-determinism):

  • Threads (with shared memory).
  • GC
  • SIMD.

It says, "Information on in-person WebAssembly meetings", but it's also used for agendas and notes for remote meetings.

@dtig, @jgravelle-google and I had a discussion this morning about the CG meetings. We all agreed that they are working well, but it may be difficult for folks to speak up if they have questions or comments, since the meetings are very technical and require a lot of context.

We were thinking of ways to improve this, and a few ideas popped up:

• Take some time during the meeting to remind people that we value all input.
• Add an agenda item to some meetings allowing people to ask questions, rather than any particular topic.
• Provide an easier environment for this type of discussion: a mailing list, slack, discord, etc.
• Provide other avenues where new people can contribute, such as a "good-first-bug" list, improving documentation, writing examples and tests, etc.

Any thoughts or other ideas?

Action item: (not done from last meeting) JZ / BN to try contacting MIPS / POWER folks to perform measurements.

Today's meeting claims to be at November 12th, 4pm-5pm UTC (November 12th, 9am-10am Pacific Daylight Time), but DST is no longer in effect in the Pacific time zone.

From WG agendas:

If you are a Community Group member who would like to observe, please register here: https://goo.gl/forms/HD2kLCM0iSKk7AVl1

I've tried to fill this form 5 times since August but never got a response. How to get a link to observe WG meetings?

As discussed on 12/12.

Testing: "Lars to propose a [common shell API] (WebAssembly/threads#52). Others to discuss."

• BS: Lars is working on it

Action item: Lars to follow up next time.

Action item: 4 browser vendors to clean up the limits.h numbers, agree on them, write tests, and unofficially support them for now. Next meeting, we’ll discuss the following polls which we didn’t take today or lack of information to for consensus.

From https://github.com/WebAssembly/meetings/blob/master/2018/CG-03-20v21.md

Would CG subcommitees be useful for some topics like:

• Exceptions
• ES6 Modules
• CSP

Do we need anything formal or would informal work?

We’re getting bigger features. Would it make sense to have optional CG meetings for people interested in these particular topics?

AI: JF to check with W3C what the process is, CC Brad and Eric Prud'hommeaux.

Do we want mailing lists? How do we organize? GitHub issues? Video chats? Sub-group chair (should those be the champions)? How do we establish charter for sub-groups? Notes, timing, other requirements?

AI: Brad and JF to update the phases proposal.

Action item: James to map out the possible opcodes we could standardize for mulhi (constant or variable right-hand side, how to handle precision).

Are there recordings of the presentations given earlier this month? Specifically This presentation?

I can't find most of the slides that were presented during TPAC. Can we have those online and linked in TPAC.md?