Uncategorized – Yet Another Needless Site

My first take on C++ coroutines

Carrot 2022-06-26

In this post I’ll go through the disassembly (commented inline) of the following C++ snippet:

#include <concepts>
#include <coroutine>

class task {
   public:
    class promise_type {
       public:
        class always_suspend {
           public:
            bool await_ready() const noexcept;
            bool await_suspend(
                std::coroutine_handle<promise_type> handle) noexcept;
            void await_resume() noexcept;
        };

        promise_type();
        always_suspend initial_suspend();
        always_suspend final_suspend() noexcept;
        void unhandled_exception();
        always_suspend yield_value(std::integral auto&& v);
        task get_return_object();

       private:
        std::coroutine_handle<promise_type> handle_;
    };
};

bool task::promise_type::always_suspend::await_ready() const noexcept {
    return false;
}

bool task::promise_type::always_suspend::await_suspend(
    std::coroutine_handle<promise_type> handle) noexcept {
    return true;
}

void task::promise_type::always_suspend::await_resume() noexcept {}

task::promise_type::promise_type() {
    handle_ = std::coroutine_handle<promise_type>::from_promise(*this);
}

task::promise_type::always_suspend task::promise_type::initial_suspend() {
    return {};
}

task::promise_type::always_suspend
task::promise_type::final_suspend() noexcept {
    return {};
}

void task::promise_type::unhandled_exception() {}

template <std::integral T>
task::promise_type::always_suspend task::promise_type::yield_value(T&& v) {
    return {};
}

task task::promise_type::get_return_object() { return {}; }

task fancy_task(int x) {
    for (int i = 0; i != 100; ++i) {
        co_yield i + x;
    }
}

int main() { auto task = fancy_task(5); }

#include <concepts>

#include <coroutine>

class task {

public:

class promise_type {

public:

class always_suspend {

public:

bool await_ready() const noexcept;

bool await_suspend(

std::coroutine_handle<promise_type> handle) noexcept;

void await_resume() noexcept;

};

promise_type();

always_suspend initial_suspend();

always_suspend final_suspend() noexcept;

void unhandled_exception();

always_suspend yield_value(std::integral auto&& v);

task get_return_object();

private:

std::coroutine_handle<promise_type> handle_;

};

bool task::promise_type::always_suspend::await_ready() const noexcept {

return false;

}

bool task::promise_type::always_suspend::await_suspend(

std::coroutine_handle<promise_type> handle) noexcept {

return true;

}

void task::promise_type::always_suspend::await_resume() noexcept {}

task::promise_type::promise_type() {

handle_ = std::coroutine_handle<promise_type>::from_promise(*this);

}

task::promise_type::always_suspend task::promise_type::initial_suspend() {

return {};

}

task::promise_type::always_suspend

task::promise_type::final_suspend() noexcept {

return {};

}

void task::promise_type::unhandled_exception() {}

template <std::integral T>

task::promise_type::always_suspend task::promise_type::yield_value(T&& v) {

return {};

}

task task::promise_type::get_return_object() { return {}; }

task fancy_task(int x) {

for (int i = 0; i != 100; ++i) {

co_yield i + x;

}

int main() { auto task = fancy_task(5); }

Disassembly:

task::promise_type::always_suspend::await_ready() const:
        mov     eax, 0
        ret
task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>):
        mov     eax, 1
        ret
fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]:
        push    rbp
        push    rbx
        sub     rsp, 8
        mov     rbx, rdi  ; `rbx` holds `coroutine_handle<>`.
        movzx   ecx, WORD PTR [rdi+36]  ; Loads current state (of the state machine the coroutine represents).
        test    cl, 1  ; Not destroying the coroutine?.
        je      .L4
        cmp     cx, 7  ; State > 3? Note that 3 comes from `7 >> 1`.
        ja      .L5  ; Unexpected then.
        mov     eax, 170  ; ???
        shr     rax, cl
        test    al, 1
        jne     .L6
.L5:  ; Unexpected state.
        ud2
.L4:
        cmp     cx, 4  ; State 2.
        je      .L7
        ja      .L8
        test    cx, cx
        je      .L9  ; State 0.
        cmp     cx, 2
        jne     .L11  ; Not state 1, either. Unexpected.
.L10:
        mov     BYTE PTR [rbx+39], 1  ; ??? state 0 finishes (i.e., `initial_suspend` called)?
        mov     DWORD PTR [rbx+44], 0  ; Initialize `i`.
        jmp     .L14
.L8:
        cmp     cx, 6  ; State 3.
        jne     .L11
.L6:  ; Epilogue. State 3.
        ; ??? Coroutine alive? 
        ;
        ; Note that this is not necessarily the same as `coroutine_handle<>.done()`,
        ; the latter returns `true` as soon as `final_suspend()` is reached, while
        ; this flag is set only after `final_suspend()` has been resumed.
        cmp     BYTE PTR [rbx+38], 0
        jne     .L17
.L3:  ; Return control to the caller.
        add     rsp, 8
        pop     rbx
        pop     rbp
        ret
.L11:  ; Unexpected state.
        ud2
.L9:  ; Prologue. State 0, runs before `initial_suspend()`.
        mov     QWORD PTR [rbx+24], rdi  ; Stores `coroutine_handle<>` in ... `coroutine_handle<>`?
        mov     BYTE PTR [rdi+39], 0  ; ??? state 0 finishes?
        lea     rbp, [rdi+40]  ; Space allocated for `always_suspend` returned by `initial_suspend()` in coroutine state.
        mov     rdi, rbp
        call    task::promise_type::always_suspend::await_ready() const
        test    al, al
        jne     .L10  ; No need to suspend.
        mov     WORD PTR [rbx+36], 2  ; Next state (of FSM this coroutine represents) will be state 1.
        mov     rsi, rbx
        mov     rdi, rbp
        call    task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>)  ; See if we really need to suspend.
        test    al, al
        jne     .L3  ; Yes, returning to the caller.
        jmp     .L10  ; Jump ahead to state 1 then.
.L7:  ; State 2. Also the beginning of the `for` loop.
        mov     eax, DWORD PTR [rbx+44]  ; Loads `i`.
        add     eax, 1
        mov     DWORD PTR [rbx+44], eax
.L14:
        mov     eax, DWORD PTR [rbx+44]
        cmp     eax, 100  ; `for` loop ends?
        je      .L18
        add     eax, DWORD PTR [rbx+32]  ; Loads `x` and adds it to `i`.
        mov     DWORD PTR [rbx+52], eax  ; Keep the result.
        lea     rbp, [rbx+48]  ; `always_suspend` object (returned by `yield_value(integral auto&&)`) allocated in coroutine state?
        mov     rdi, rbp
        call    task::promise_type::always_suspend::await_ready() const  ; See if we need to suspend.
        test    al, al
        jne     .L7  ; No need to suspend.
        mov     WORD PTR [rbx+36], 4
        mov     rsi, QWORD PTR [rbx+24]  ; `coroutine_handle<>`.
        mov     rdi, rbp
        call    task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>)
        test    al, al  ; Needs to suspend?
        jne     .L3  ; Yes, leaving.
        jmp     .L7  ; Otherwise keep looping.
.L18:  ; `for` loop ends.
        ; Clear pointer to FSM represented by this coroutine.
        ;
        ; Indicates `coroutine_handle::done()`?
        ;
        ; As a reminder, resuming a coroutine suspended on its `final_suspend()` is U.B,
        ; therefore setting FSM to `nullptr` prior to calling `final_suspend()` won't
        ; hurt well-formed programs.
        mov     QWORD PTR [rbx], 0
        lea     rbp, [rbx+56]  ; `always_suspend` for `final_suspend()`.
        mov     rdi, rbp
        call    task::promise_type::always_suspend::await_ready() const
        test    al, al
        jne     .L6  ; Don't suspend, falling through to state 3.
        mov     WORD PTR [rbx+36], 6  ; Next state is 3.
        mov     rsi, QWORD PTR [rbx+24]  ; `coroutine_handle<>`.
        mov     rdi, rbp
        call    task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>)
        test    al, al
        jne     .L3  ; Suspend, returning to the caller.
        jmp     .L6  ; No need to suspend, continuing state 3.
.L17:  ; Destroyes the coroutine.
        mov     rdi, rbx
        call    operator delete(void*)
        jmp     .L3
fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .destroy]:
        sub     rsp, 8
        or      WORD PTR [rdi+36], 1  # LSB set to 1 indicates leaving?
        call    fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]
        add     rsp, 8
        ret
task::promise_type::always_suspend::await_resume():
        ret
task::promise_type::promise_type() [base object constructor]:
        mov     QWORD PTR [rdi], 0
        lea     rax, [rdi-16]  ; `coroutine_handle`.
        mov     QWORD PTR [rdi], rax
        ret
task::promise_type::initial_suspend():
        ret
task::promise_type::final_suspend():
        ret
task::promise_type::unhandled_exception():
        ret
task::promise_type::get_return_object():
        ret
fancy_task(int):
        push    rbp
        push    rbx
        sub     rsp, 8
        mov     ebp, edi
        mov     edi, 64
        ; Allocates coroutine state (stack frame, actually). The `coroutine_handle<>`
        ; also holds this value (at least on GCC).
        call    operator new(unsigned long)
        mov     rbx, rax
        mov     BYTE PTR [rax+38], 1  ; ??? Coroutine alive?
        ; State machine? Seemingly reset to `nullptr` on coroutine completion (i.e.,
        ; `coroutine_handle<>.done()`)
        mov     QWORD PTR [rax], OFFSET FLAT:fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]
        mov     QWORD PTR [rax+8], OFFSET FLAT:fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .destroy]  ; `coroutine_handle.destroy`
        mov     DWORD PTR [rax+32], ebp  ; Saves stack pointer
        lea     rdi, [rax+16]  ; Pointer to promise object contained by coroutine state.
        call    task::promise_type::promise_type() [complete object constructor]
        mov     WORD PTR [rbx+36], 0  ; Current state?
        mov     rdi, rbx
        call    fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]  ; Enter the state machine.
        add     rsp, 8
        pop     rbx
        pop     rbp
        ret
main:
        sub     rsp, 8
        mov     edi, 5  ; Our argument to `fancy_task`
        call    fancy_task(int)
        mov     eax, 0
        add     rsp, 8
        ret

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

task::promise_type::always_suspend::await_ready() const:

mov eax, 0

ret

task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>):

mov eax, 1

ret

fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]:

push rbp

push rbx

sub rsp, 8

mov rbx, rdi ; `rbx` holds `coroutine_handle<>`.

movzx ecx, WORD PTR [rdi+36] ; Loads current state (of the state machine the coroutine represents).

test cl, 1 ; Not destroying the coroutine?.

je .L4

cmp cx, 7 ; State > 3? Note that 3 comes from `7 >> 1`.

ja .L5 ; Unexpected then.

mov eax, 170 ; ???

shr rax, cl

test al, 1

jne .L6

.L5: ; Unexpected state.

ud2

.L4:

cmp cx, 4 ; State 2.

je .L7

ja .L8

test cx, cx

je .L9 ; State 0.

cmp cx, 2

jne .L11 ; Not state 1, either. Unexpected.

.L10:

mov BYTE PTR [rbx+39], 1 ; ??? state 0 finishes (i.e., `initial_suspend` called)?

mov DWORD PTR [rbx+44], 0 ; Initialize `i`.

jmp .L14

.L8:

cmp cx, 6 ; State 3.

jne .L11

.L6: ; Epilogue. State 3.

; ??? Coroutine alive?

;

; Note that this is not necessarily the same as `coroutine_handle<>.done()`,

; the latter returns `true` as soon as `final_suspend()` is reached, while

; this flag is set only after `final_suspend()` has been resumed.

cmp BYTE PTR [rbx+38], 0

jne .L17

.L3: ; Return control to the caller.

add rsp, 8

pop rbx

pop rbp

ret

.L11: ; Unexpected state.

ud2

.L9: ; Prologue. State 0, runs before `initial_suspend()`.

mov QWORD PTR [rbx+24], rdi ; Stores `coroutine_handle<>` in ... `coroutine_handle<>`?

mov BYTE PTR [rdi+39], 0 ; ??? state 0 finishes?

lea rbp, [rdi+40] ; Space allocated for `always_suspend` returned by `initial_suspend()` in coroutine state.

mov rdi, rbp

call task::promise_type::always_suspend::await_ready() const

test al, al

jne .L10 ; No need to suspend.

mov WORD PTR [rbx+36], 2 ; Next state (of FSM this coroutine represents) will be state 1.

mov rsi, rbx

mov rdi, rbp

call task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>) ; See if we really need to suspend.

test al, al

jne .L3 ; Yes, returning to the caller.

jmp .L10 ; Jump ahead to state 1 then.

.L7: ; State 2. Also the beginning of the `for` loop.

mov eax, DWORD PTR [rbx+44] ; Loads `i`.

add eax, 1

mov DWORD PTR [rbx+44], eax

.L14:

mov eax, DWORD PTR [rbx+44]

cmp eax, 100 ; `for` loop ends?

je .L18

add eax, DWORD PTR [rbx+32] ; Loads `x` and adds it to `i`.

mov DWORD PTR [rbx+52], eax ; Keep the result.

lea rbp, [rbx+48] ; `always_suspend` object (returned by `yield_value(integral auto&&)`) allocated in coroutine state?

mov rdi, rbp

call task::promise_type::always_suspend::await_ready() const ; See if we need to suspend.

test al, al

jne .L7 ; No need to suspend.

mov WORD PTR [rbx+36], 4

mov rsi, QWORD PTR [rbx+24] ; `coroutine_handle<>`.

mov rdi, rbp

call task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>)

test al, al ; Needs to suspend?

jne .L3 ; Yes, leaving.

jmp .L7 ; Otherwise keep looping.

.L18: ; `for` loop ends.

; Clear pointer to FSM represented by this coroutine.

;

; Indicates `coroutine_handle::done()`?

;

; As a reminder, resuming a coroutine suspended on its `final_suspend()` is U.B,

; therefore setting FSM to `nullptr` prior to calling `final_suspend()` won't

; hurt well-formed programs.

mov QWORD PTR [rbx], 0

lea rbp, [rbx+56] ; `always_suspend` for `final_suspend()`.

mov rdi, rbp

call task::promise_type::always_suspend::await_ready() const

test al, al

jne .L6 ; Don't suspend, falling through to state 3.

mov WORD PTR [rbx+36], 6 ; Next state is 3.

mov rsi, QWORD PTR [rbx+24] ; `coroutine_handle<>`.

mov rdi, rbp

call task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>)

test al, al

jne .L3 ; Suspend, returning to the caller.

jmp .L6 ; No need to suspend, continuing state 3.

.L17: ; Destroyes the coroutine.

mov rdi, rbx

call operator delete(void*)

jmp .L3

fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .destroy]:

sub rsp, 8

or WORD PTR [rdi+36], 1 # LSB set to 1 indicates leaving?

call fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]

add rsp, 8

ret

task::promise_type::always_suspend::await_resume():

ret

task::promise_type::promise_type() [base object constructor]:

mov QWORD PTR [rdi], 0

lea rax, [rdi-16] ; `coroutine_handle`.

mov QWORD PTR [rdi], rax

ret

task::promise_type::initial_suspend():

ret

task::promise_type::final_suspend():

ret

task::promise_type::unhandled_exception():

ret

task::promise_type::get_return_object():

ret

fancy_task(int):

push rbp

push rbx

sub rsp, 8

mov ebp, edi

mov edi, 64

; Allocates coroutine state (stack frame, actually). The `coroutine_handle<>`

; also holds this value (at least on GCC).

call operator new(unsigned long)

mov rbx, rax

mov BYTE PTR [rax+38], 1 ; ??? Coroutine alive?

; State machine? Seemingly reset to `nullptr` on coroutine completion (i.e.,

; `coroutine_handle<>.done()`)

mov QWORD PTR [rax], OFFSET FLAT:fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]

mov QWORD PTR [rax+8], OFFSET FLAT:fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .destroy] ; `coroutine_handle.destroy`

mov DWORD PTR [rax+32], ebp ; Saves stack pointer

lea rdi, [rax+16] ; Pointer to promise object contained by coroutine state.

call task::promise_type::promise_type() [complete object constructor]

mov WORD PTR [rbx+36], 0 ; Current state?

mov rdi, rbx

call fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor] ; Enter the state machine.

add rsp, 8

pop rbx

pop rbp

ret

main:

sub rsp, 8

mov edi, 5 ; Our argument to `fancy_task`

call fancy_task(int)

mov eax, 0

add rsp, 8

ret

High ping latency with iOS devices (iPad / iPhone)

Carrot 2019-03-24

pinging my iPad / iPhone shows an unreasonable high latency even if there’s no load on WiFi:

# ping 1.1.1.2
PING 1.1.1.2 (1.1.1.2) 56(84) bytes of data.
64 bytes from 1.1.1.2: icmp_seq=1 ttl=64 time=15.7 ms
64 bytes from 1.1.1.2: icmp_seq=2 ttl=64 time=42.0 ms
64 bytes from 1.1.1.2: icmp_seq=3 ttl=64 time=65.2 ms
64 bytes from 1.1.1.2: icmp_seq=4 ttl=64 time=89.4 ms

# ping 1.1.1.2

PING 1.1.1.2 (1.1.1.2) 56(84) bytes of data.

64 bytes from 1.1.1.2: icmp_seq=1 ttl=64 time=15.7 ms

64 bytes from 1.1.1.2: icmp_seq=2 ttl=64 time=42.0 ms

64 bytes from 1.1.1.2: icmp_seq=3 ttl=64 time=65.2 ms

64 bytes from 1.1.1.2: icmp_seq=4 ttl=64 time=89.4 ms

… while pinging my other devices from the iPad does show aContinue reading

Hello world!

Carrot 2018-10-27

Welcome to WordPress. This is your first post. Edit or delete it, then start writing!