source: tests/io/comp_fair.cfa @ 50ff1d0

ADTast-experimentalpthread-emulation
Last change on this file since 50ff1d0 was 1417f6b, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Changed comp_fair to use a barrier rather than a semaphore.

  • Property mode set to 100644
File size: 3.0 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      bool do_read = has_user_level_blocking( (fptr_t)async_read );
68
69      for(TIMES) {
70            io_future_t f;
71            if ( do_read ) {
72                  char thrash[1];
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( 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.