Page MenuHomePhorge
Files F114139

No OneTemporary
Actions

Size
13 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/doc.org b/doc.org
index 00b7546..428eb17 100644
--- a/doc.org
+++ b/doc.org
@@ -1,178 +1,186 @@
#+PROPERTY: header-args :exports code
#+HTML_HEAD: <link rel="stylesheet" href="./style.css">
* Intro
Using [[https://github.com/arximboldi/lager][lager]] with Qt/QML
- tusooa, maintainer of [[https://kazv.chat][kazv]], [[https://lily-is.land/tusooa]] [[https://invent.kde.org/tusooaw]]
- Dmitry Kazakov, developer of [[https://krita.org][Krita]], https://invent.kde.org/dkazakov
* What is lager?
- Library to help with *value-oriented design*
- Store application state as a *value* type (*model*)
- State transformations are described in pure functions (*reducers*)
- src_c++{auto update(Model, Action) -> Model;}
- *Actions* are also value types
* What is a value type?
- Copyable
- Equality comparable
#+BEGIN_SRC c++
T a = ...;
T b = a;
REQUIRE(a == b);
#+END_SRC
- Identity does not depend on a reference
#+BEGIN_SRC c++
// not a value type
struct Person
{
std::string name;
std::vector<std::weak_ptr<Person>> contacts;
};
// value type
struct Person
{
using IdType = std::string;
IdType id;
std::string name;
std::vector<IdType> contacts;
};
#+END_SRC
- You can still use pointers internally
* Basic example of a value-oriented program
=logic.hpp=
#+INCLUDE: "src/basic-example/logic.hpp" src c++
=logic.cpp=
#+INCLUDE: "src/basic-example/logic.cpp" src c++
=main.cpp=
#+INCLUDE: "src/basic-example/main.cpp" src c++
The basic example just covered doesn't even make use of lager (!!!)
* Benefits of using lager?
- Testability
- libkazv: [[https://lily-is.land/kazv/libkazv][76.9%]] test coverage
- libQuotient: [[https://sonarcloud.io/component_measures?metric=coverage&selected=quotient-im_libQuotient%3AQuotient&id=quotient-im_libQuotient][41.6%]] (raw), 46.9% (adjusted)
=test.cpp=
#+INCLUDE: "src/basic-example/test.cpp" src c++
- Offload work into worker threads
#+BEGIN_SRC c++
QtConcurrent::run([model]() { // capture model by value
save(model);
});
#+END_SRC
- Performance of copying? Structural sharing, [[https://github.com/arximboldi/immer][immer]] containers (constant time copy ctor)
- In Qt: QSharedDataPointer (simple, all-or-nothing sharing)
- Undo/redo for free
- History is a list of models
- Undo/redo = changing the current index
- Normal actions = push a new model onto the list
- [[https://github.com/arximboldi/ewig][ewig]], a text editor
* How to do IO?
** Reducers revisited
- Recall reducers are pure functions
- src_c++{auto update(Model, Action) -> Model;}
- But also src_c++{auto update(Model, Action) -> std::pair<Model, Effect>;}
- What is an *effect*? A (maybe non-pure) function that takes a *context* as an argument.
- A *store* contains the model and the context. It also has an event loop. Reducers will be run in the event loop.
- The store can be constructed with *dependencies*, which can be accessed through the context.
- The context can also be used to dispatch actions.
=model.hpp=
#+INCLUDE: "src/effects-example/model.hpp" src c++
=main.cpp=
#+INCLUDE: "src/effects-example/main.cpp" src c++
* How can lager help you integrate value-oriented design with a Qt application?
** Missing part: view
- In the example, src_c++{show()} is the view.
- We want to show the state as a src_c++{QWidget} or src_c++{QQuickItem}.
- Signal/slot connections to update display values.
- [[https://sinusoid.es/lager/cursors.html][Cursors]]
- src_c++{lager::reader} - readonly cursors
- src_c++{reader}s can be watched
- src_c++{lager::store} is a reader
- src_c++{map}-transformations and some lenses
- src_c++{LAGER_QT} and src_c++{LAGER_QT_READER}
=demo-app.hpp=
#+INCLUDE: "src/qml-example/demo-app.hpp" src c++
=demo-app.cpp=
#+INCLUDE: "src/qml-example/demo-app.cpp" src c++
=Main.qml=
#+INCLUDE: "src/qml-example/Main.qml" src c++
=main.cpp=
#+INCLUDE: "src/qml-example/main.cpp" src c++
* Practical application problems
Or: what =lager='s author didn't tell you
* List views
[[https://github.com/arximboldi/lager/issues/179]]
** Number as model in QML ListView
=demo-app.hpp=
#+INCLUDE: "src/list-view/demo-app.hpp" src c++
=demo-app.cpp=
#+INCLUDE: "src/list-view/demo-app.cpp" src c++
=demo-list.hpp=
#+INCLUDE: "src/list-view/demo-list.hpp" src c++
=demo-list.cpp=
#+INCLUDE: "src/list-view/demo-list.cpp" src c++
=demo-item.hpp=
#+INCLUDE: "src/list-view/demo-item.hpp" src c++
=demo-item.cpp=
#+INCLUDE: "src/list-view/demo-item.cpp" src c++
=Main.qml=
#+INCLUDE: "src/list-view/Main.qml" src qml
- Problem: scroll will reset every time we add/remove an item
- https://github.com/arximboldi/lager/issues/179
** Using a src_c++{QAbstractListModel}
=demo-list.hpp=
#+INCLUDE: "src/list-view-qt-model/demo-list.hpp" src c++
=demo-list.cpp=
#+INCLUDE: "src/list-view-qt-model/demo-list.cpp" src c++
=Main.qml=
#+INCLUDE: "src/list-view-qt-model/Main.qml" src qml
* Post-dispatch then-continuations
[[https://github.com/arximboldi/lager/issues/96]], [[https://github.com/arximboldi/lager/issues/106]]
#+BEGIN_SRC c++
// XXX Why can't I just use QMetaObject::invokeMethod
// with QueuedConnection?
// Let's bear with it now. Will go back to this later.
QTimer::singleShot(100, obj, [=]() {
repl(obj, ctx);
});
#+END_SRC
- If I use src_c++{invokeMethod}, what happens if I enter 2?
- src_c++{IncrementTwiceAction} is dispatched (reducer is queued)
- src_c++{repl} is queued
- Reducer is run
- Effect is run
- Two src_c++{IncrementAction} are dispatched
- src_c++{repl} is run
- It blocks the thread! Execution of reducers for the src_c++{IncrementAction}s are not run!
- We want it to run after src_c++{IncrementTwiceAction} has really finished
- If action A's effect dispatches B and B's effect dispatches C and C's effect dispatches D
- Want the chain to finish all the way
- lager does not support this (limited support at the time)
- Resolved by creating [[https://lily-is.land/kazv/libkazv/-/blob/servant/src/store/store.hpp?ref_type=heads][another kind of store]]
- Effects return a Promise (for C++ programmers, it's more like src_c++{std::future}) instead of void
- src_c++{dispatch} can be src_c++{then}-ed, the callback will be run after the returned future becomes ready
#+INCLUDE: "src/libkazvstore-example/main.cpp" src c++
* Offloading work into worker threads
- src_c++{ctx.dispatch} is thread-safe, can use it to pass down the result of a heavy computation
- When heavy computation needs to be atomic, put the event loop into a worker thread
- Create a secondary store that has an event loop in the UI thread
- This is needed because cursor operations are not thread-safe [[https://github.com/arximboldi/lager/issues/118]]
+=model.hpp=
+#+INCLUDE: "src/multithreading/model.hpp" src c++
+=demo-app.hpp=
+#+INCLUDE: "src/multithreading/demo-app.hpp" src c++
+=demo-app.cpp=
+#+INCLUDE: "src/multithreading/demo-app.cpp" src c++
+=Main.qml=
+#+INCLUDE: "src/multithreading/Main.qml" src qml
* Using src_c++{lager::state} (leave to Dmitry)
* Appendix
** Calculating libQuotient coverage adjusted
libQuotient includes the generated csapi folder into coverage, while libkazv does not. Here is the code that calculates the coverage of libQuotient excluding the csapi folder.
#+NAME: libquotient-coverage
#+BEGIN_SRC perl
my $csapiCoverage = 0.169;
my $csapiUncovered = 1_668;
my $totalLines = 11_229;
my $totalUncovered = 6_561;
my $csapiLines = $csapiUncovered / (1-$csapiCoverage);
my $remainingLines = $totalLines - $csapiLines;
my $remainingUncovered = $totalUncovered - $csapiUncovered;
my $remainingCoverage = 1 - $remainingUncovered / $remainingLines;
$remainingCoverage;
#+END_SRC
#+RESULTS: libquotient-coverage
: 0.46940827964562
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9bdd59d..c6fff96 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,8 +1,9 @@
add_subdirectory(basic-example)
add_subdirectory(effects-example)
add_subdirectory(qml-example)
add_subdirectory(list-view)
add_subdirectory(list-view-qt-model)
if(libkazv_FOUND)
add_subdirectory(libkazvstore-example)
endif()
+add_subdirectory(multithreading)
diff --git a/src/multithreading/CMakeLists.txt b/src/multithreading/CMakeLists.txt
new file mode 100644
index 0000000..cbb0efb
--- /dev/null
+++ b/src/multithreading/CMakeLists.txt
@@ -0,0 +1,25 @@
+qt_add_qml_module(multi-threading-qmlmodule
+ STATIC
+ URI land.lilyis.tusooa.lagerqtdemo.multithreading
+ VERSION 0.0
+ SOURCES demo-app.cpp
+ QML_FILES Main.qml
+)
+
+target_link_libraries(multi-threading-qmlmodule
+ PUBLIC
+ Qt6::Quick
+ Qt6::Concurrent
+)
+
+add_executable(multithreading-demo
+ main.cpp
+)
+
+target_link_libraries(multithreading-demo
+ PRIVATE
+ Qt6::Gui
+ Qt6::Widgets
+ multi-threading-qmlmodule
+ multi-threading-qmlmoduleplugin
+)
diff --git a/src/multithreading/Main.qml b/src/multithreading/Main.qml
new file mode 100644
index 0000000..9751a69
--- /dev/null
+++ b/src/multithreading/Main.qml
@@ -0,0 +1,29 @@
+
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+import org.kde.kirigami as Kirigami
+import land.lilyis.tusooa.lagerqtdemo.multithreading
+
+Kirigami.ApplicationWindow {
+ id: root
+ property DemoApp app: DemoApp {}
+ pageStack.initialPage: Kirigami.ScrollablePage {
+ ColumnLayout {
+ Label {
+ text: `f(${app.n}) = ${app.fn}`
+ Layout.fillWidth: true
+ }
+ TextField {
+ id: numInput
+ Layout.fillWidth: true
+ text: `${app.n}`
+ }
+ Button {
+ text: 'Set n'
+ Layout.fillWidth: true
+ onClicked: app.set(parseInt(numInput.text))
+ }
+ }
+ }
+}
diff --git a/src/multithreading/demo-app.cpp b/src/multithreading/demo-app.cpp
new file mode 100644
index 0000000..d32b8f8
--- /dev/null
+++ b/src/multithreading/demo-app.cpp
@@ -0,0 +1,66 @@
+
+#include <immer/config.hpp>
+#include <lager/config.hpp>
+#include <lager/store.hpp>
+#include <lager/setter.hpp>
+#include <lager/event_loop/qt.hpp>
+#include "demo-app.hpp"
+#include "model.hpp"
+
+struct DemoApp::Private
+{
+ QThread *thread;
+ QObject *obj;
+ lager::store<Action, Model> primaryStore;
+ lager::store<Model, Model> secondaryStore;
+
+ Private(DemoApp *q)
+ : thread(new QThread)
+ , obj(new QObject)
+ , primaryStore(lager::make_store<Action>(
+ Model{},
+ lager::with_qt_event_loop{*obj}
+ ))
+ , secondaryStore(lager::make_store<Model>(
+ Model{},
+ lager::with_qt_event_loop{*q},
+ lager::with_reducer([]([[maybe_unused]] Model prev, Model next) {
+ return next;
+ }
+ )))
+ {
+ obj->moveToThread(thread);
+ lager::watch(primaryStore,
+ [ctx=static_cast<lager::context<Model>>(secondaryStore)](Model m) {
+ ctx.dispatch(m);
+ });
+ thread->start();
+ }
+
+ ~Private()
+ {
+ thread->quit();
+ thread->wait();
+ thread->deleteLater();
+ obj->deleteLater();
+ }
+};
+
+DemoApp::DemoApp(QObject *parent)
+ : QObject(parent)
+ , m_d(std::make_unique<Private>(this))
+ , LAGER_QT(n)(m_d->secondaryStore.map([](Model m) {
+ return m.n;
+ }))
+ , LAGER_QT(fn)(m_d->secondaryStore.map([](Model m) {
+ return m.fn;
+ }))
+{
+}
+
+DemoApp::~DemoApp() = default;
+
+void DemoApp::set(int n)
+{
+ m_d->primaryStore.dispatch(ResetAction{n});
+}
diff --git a/src/multithreading/demo-app.hpp b/src/multithreading/demo-app.hpp
new file mode 100644
index 0000000..2275bf5
--- /dev/null
+++ b/src/multithreading/demo-app.hpp
@@ -0,0 +1,27 @@
+
+#pragma once
+#include <immer/config.hpp>
+#include <lager/config.hpp>
+#include <memory>
+#include <lager/extra/qt.hpp>
+#include <QObject>
+#include <QQmlEngine>
+
+class DemoApp : public QObject
+{
+ Q_OBJECT
+ QML_ELEMENT
+
+ struct Private;
+ std::unique_ptr<Private> m_d;
+
+public:
+ DemoApp(QObject *parent = nullptr);
+ ~DemoApp() override;
+
+ LAGER_QT_READER(int, n);
+
+ LAGER_QT_READER(int, fn);
+
+ Q_INVOKABLE void set(int n);
+};
diff --git a/src/multithreading/main.cpp b/src/multithreading/main.cpp
new file mode 100644
index 0000000..7423fb3
--- /dev/null
+++ b/src/multithreading/main.cpp
@@ -0,0 +1,14 @@
+
+#include <QApplication>
+#include <QQmlApplicationEngine>
+
+using namespace Qt::Literals::StringLiterals;
+
+int main(int argc, char *argv[])
+{
+ QApplication app(argc, argv);
+ QQmlApplicationEngine engine;
+ engine.loadFromModule(u"land.lilyis.tusooa.lagerqtdemo.multithreading"_s, u"Main"_s);
+
+ return app.exec();
+}
diff --git a/src/multithreading/model.hpp b/src/multithreading/model.hpp
new file mode 100644
index 0000000..497e731
--- /dev/null
+++ b/src/multithreading/model.hpp
@@ -0,0 +1,37 @@
+
+#pragma once
+#include <variant>
+#include <thread>
+
+struct Model
+{
+ int n{0};
+ int fn{0};
+};
+
+struct ResetAction
+{
+ int n;
+};
+
+using Action = std::variant<ResetAction>;
+
+inline int heavyComputation(int n)
+{
+ std::this_thread::sleep_for(std::chrono::seconds(2));
+ return n * 2;
+}
+
+inline Model update([[maybe_unused]] Model m, ResetAction a)
+{
+ m.n = a.n;
+ m.fn = heavyComputation(m.n);
+ return m;
+}
+
+inline Model update([[maybe_unused]] Model m, Action a)
+{
+ return std::visit([&](auto action) {
+ return update(m, action);
+ }, a);
+}

File Metadata

Mime Type
text/x-diff
Expires
Mon, Nov 25, 8:33 PM (1 d, 8 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
40065
Default Alt Text
(13 KB)

Event Timeline