source: tests/io/comp_fair.cfa @ d2ad151

ADTast-experimental
Last change on this file since d2ad151 was d2ad151, checked in by Peter A. Buhr <pabuhr@…>, 18 months ago

major update of PRNG

  • Property mode set to 100644
File size: 2.7 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2022 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// comp_fair.cfa -- Test that spinning doesn't cause completions to get stuck.
8//                  This test should work without io_uring but isn't very useful without
9//
10// Author           : Thierry Delisle
11// Created On       : Thu Mar 10 15:06:50 2022
12// Last Modified By :
13// Last Modified On :
14// Update Count     :
15//
16
17
18#include <concurrency/barrier.hfa>
19#include <fstream.hfa>
20#include <iofwd.hfa>
21#include <kernel.hfa>
22#include <thread.hfa>
23
24#include <errno.h>
25#include <string.h>
26#include <unistd.h>
27
28struct {
29        barrier & bar;
30        int pipe[2];
31
32} globals;
33
34Duration default_preemption() {
35        return 0;
36}
37
38enum { TIMES = 1000 };
39
40volatile unsigned counter = 0;
41
42
43// ----- Spinner -----
44// spins trying to prevent other threads from getting to this processor
45thread Spinner {};
46void main(Spinner &) {
47        unsigned last = 0;
48        for() {
49                unsigned curr = __atomic_load_n(&counter, __ATOMIC_SEQ_CST);
50
51                if(curr >= TIMES) break;
52
53                if(last == curr) {
54                        Pause();
55                        continue;
56                }
57
58                last = curr;
59                yield();
60        }
61}
62
63// ----- Reader -----
64// Reader from the pipe to test completion doesn't starve
65thread Reader {};
66void main(Reader & this) {
67        char thrash[1];
68        bool do_read = has_user_level_blocking( (fptr_t)async_read );
69
70        for(TIMES) {
71                io_future_t f;
72                if ( do_read ) {
73                        async_read(f, globals.pipe[0], thrash, 1, 0);
74                } else {
75                        fulfil(f, 0); // If we don't have user-level blocking just play along
76                }
77
78                block( globals.bar );
79
80                yield( (unsigned)prng( this, 15 ) );
81
82                unsigned i = __atomic_add_fetch( &counter, 1, __ATOMIC_SEQ_CST );
83                if(0 == (i % 100)) sout | i;
84
85                wait( f );
86
87                if(f.result < 0)
88                        abort | "Read error" | -f.result | ":" | strerror(-f.result);
89
90                block( globals.bar );
91        }
92}
93
94// ----- Writer -----
95// Writes to the pipe so the Reader can unblock
96// takes its sweet time so the Reader has to block
97thread Writer {};
98void main(Writer & this) {
99        for(TIMES) {
100                block( globals.bar );
101
102                sleep( 1`us );
103
104                char buf[1] = { '+' };
105                int ret = write( globals.pipe[1], buf, 1 );
106                if(ret < 0)
107                        abort | "Write error" | errno | ":" | strerror(errno);
108
109                block( globals.bar );
110        }
111}
112
113// ----- Yielder -----
114// Add some chaos into the mix
115thread Yielder {};
116void ^?{}(Yielder &mutex ) {}
117void main(Yielder&) {
118        while(TIMES > __atomic_load_n(&counter, __ATOMIC_SEQ_CST)) {
119                yield();
120        }
121}
122
123int main() {
124        barrier bar = { 2 };
125        &globals.bar = &bar;
126        int ret = pipe(globals.pipe);
127        if(ret != 0)
128                abort | "Pipe error" | errno | ":" | strerror(errno);
129
130        processor p;
131        sout | "starting";
132        {
133                Yielder y;
134                Spinner s;
135                Reader ior;
136                Writer iow;
137        }
138        sout | "done";
139}
Note: See TracBrowser for help on using the repository browser.