And for the new year 0.3.0:
[https://github.com/mratsim/weave/releases/tag/v0.3.0](https://github.com/mratsim/weave/releases/tag/v0.3.0)
Next developments will probably take a while as the "low-hanging" fruits are
done (i.e. from my PoC in July/August). If someone wants to add something like
gr
I can't edit my title but I'm happy to announce the release of Weave 0.2.0
codenamed "Overture".
This is the result of a fight of over 8 hours to add reconcile setting $PATH in
Azure Pipelines and nimble/findExe.
Weave now supports Windows in addition to Linux, macOS and all platforms with
Pth
I only support trivial types, checked at compile-time via supportsCopyMem(T).
What I do is here:
[https://github.com/mratsim/weave/blob/v0.1.0/weave/parallel_tasks.nim#L125-L150](https://github.com/mratsim/weave/blob/v0.1.0/weave/parallel_tasks.nim#L125-L150)
From the function call `spawn foo(a,
This is excellent work, but what is the protocol that your `spawn` uses/needs.
I'm asking because I'm wondering about `=sink` vs `=move` vs `=deepCopy` as the
fundamental building block for thread communication. Rust has both `send` and
`sync`, see
[https://doc.rust-lang.org/nomicon/send-and-sy
@mratsim, Sorry. I should have been more specific.
I didn't mean to compare Weave to those Rust libraries in terms of features. I
was comparing them in terms of library size and level of abstraction (for lack
of a better phrase.)
What I meant to say is both Tokio and Rayon are "runtime" librari
A `runtime` means something that operates at `runtime` with extra overhead
compared to anything done at compile-time by the compiler. It also means
potentially interoperability issue.
For example, a garbage collector or a reference counting scheme is also a
runtime, extra overhead, not done at
It's similar to the Rayon or Tokio libraries from Rust.
Weave provides a set of fundamental building blocks to create safe and high
performance multi-threaded programs.
Anyone who wants to write multi-threaded programs in Nim should be very excited
about this.
like Rust, Nim itself provides a
Sorry, my question was basically: what does the word runtime mean? Does it
replace certain operations in the executable that the Nim compiler produces by
default, in that case, it's a low level integration with Nim, the compiler. So,
what do the users need to do to use this multithreading runtim
> Does this aim to be part of Nim?
No
> Part of the standard library?
It's probably too big, though some of the underlying code like the memory
subsystem could be in the standard library.
> Does it have an accessible api?
spawn/sync/Flowvar are directly taken from
[https://nim-lang.org/docs/
Does this aim to be part of Nim? Part of the standard library? Does it have an
accessible api, that feels like idiomatic nim code?
Thanks!
It's been a while since the RFC Picasso multithreading runtime
([https://github.com/nim-lang/RFCs/issues/160](https://github.com/nim-lang/RFCs/issues/160)
/ [https://forum.nim-lang.org/t/5083)](https://forum.nim-lang.org/t/5083\)).
The project is living at
[https://github.com/mratsim/weave](htt
11 matches
Mail list logo
