source: src/Concurrency/Waitfor.cc@ f90d10f

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since f90d10f was ac2b598, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

Changed descriptors for concurrency to use $ prefix instead of trailing _desc
  • Property mode set to 100644
File size: 15.3 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 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// Waitfor.cc --
8//
9// Author : Thierry Delisle
10// Created On : Mon Aug 28 11:06:52 2017
11// Last Modified By :
12// Last Modified On :
13// Update Count : 12
14//
15
16#include "Concurrency/Keywords.h"
17
18#include <cassert> // for assert
19#include <string> // for string, operator==
20
21using namespace std::string_literals;
22
23#include "Common/PassVisitor.h" // for PassVisitor
24#include "Common/SemanticError.h" // for SemanticError
25#include "Common/UniqueName.h" // for UniqueName
26#include "Common/utility.h" // for deleteAll, map_range
27#include "CodeGen/OperatorTable.h" // for isConstructor
28#include "InitTweak/InitTweak.h" // for getPointerBase
29#include "ResolvExpr/Resolver.h" // for findVoidExpression
30#include "SynTree/LinkageSpec.h" // for Cforall
31#include "SynTree/Constant.h" // for Constant
32#include "SynTree/Declaration.h" // for StructDecl, FunctionDecl, ObjectDecl
33#include "SynTree/Expression.h" // for VariableExpr, ConstantExpr, Untype...
34#include "SynTree/Initializer.h" // for SingleInit, ListInit, Initializer ...
35#include "SynTree/Label.h" // for Label
36#include "SynTree/Statement.h" // for CompoundStmt, DeclStmt, ExprStmt
37#include "SynTree/Type.h" // for StructInstType, Type, PointerType
38#include "SynTree/Visitor.h" // for Visitor, acceptAll
39
40class Attribute;
41/*
42void foo() {
43 while( true ) {
44 when( a < 1 ) waitfor( f : a ) { bar(); }
45 or timeout( swagl() );
46 or waitfor( g : a ) { baz(); }
47 or waitfor( ^?{} : a ) { break; }
48 or waitfor( ^?{} ) { break; }
49 }
50}
51
52void f(int i, float f, A & mutex b, struct foo * );
53void f(int );
54
55
56 | |
57 | |
58 | |
59 | |
60 | |
61 \ | | /
62 \ /
63 \ /
64 \/
65
66
67void foo() {
68 while( true ) {
69 {
70 acceptable_t acceptables[3];
71 if( a < 1 ) {
72 acceptables[0].func = f;
73 acceptables[0].mon = a;
74 }
75 acceptables[1].func = g;
76 acceptables[1].mon = a;
77
78 acceptables[2].func = f;
79 acceptables[2].mon = a;
80 acceptables[2].is_dtor = true;
81
82 int ret = waitfor_internal( acceptables, swagl() );
83
84 switch( ret ) {
85 case 0:
86 {
87 bar();
88 }
89 case 1:
90 {
91 baz();
92 }
93 case 2:
94 signal(a);
95 {
96 break;
97 }
98 }
99 }
100 }
101}*/
102
103namespace Concurrency {
104 //=============================================================================================
105 // Pass declarations
106 //=============================================================================================
107
108 class GenerateWaitForPass final : public WithIndexer {
109 public:
110
111 void premutate( FunctionDecl * decl );
112 void premutate( StructDecl * decl );
113
114 Statement * postmutate( WaitForStmt * stmt );
115
116 static void generate( std::list< Declaration * > & translationUnit ) {
117 PassVisitor< GenerateWaitForPass > impl;
118 acceptAll( translationUnit, impl );
119 }
120
121 ObjectDecl * declare( unsigned long count, CompoundStmt * stmt );
122 ObjectDecl * declareFlag( CompoundStmt * stmt );
123 Statement * makeSetter( ObjectDecl * flag );
124 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
125 void init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt );
126 Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt );
127 Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
128 void choose( WaitForStmt * waitfor, Expression * result, CompoundStmt * stmt );
129
130 static void implement( std::list< Declaration * > & translationUnit ) {
131 PassVisitor< GenerateWaitForPass > impl;
132 mutateAll( translationUnit, impl );
133 }
134
135
136 private:
137 FunctionDecl * decl_waitfor = nullptr;
138 StructDecl * decl_mask = nullptr;
139 StructDecl * decl_acceptable = nullptr;
140 StructDecl * decl_monitor = nullptr;
141
142 static std::unique_ptr< Type > generic_func;
143
144 UniqueName namer_acc = "__acceptables_"s;
145 UniqueName namer_idx = "__index_"s;
146 UniqueName namer_flg = "__do_run_"s;
147 UniqueName namer_msk = "__mask_"s;
148 UniqueName namer_mon = "__monitors_"s;
149 UniqueName namer_tim = "__timeout_"s;
150 };
151
152 //=============================================================================================
153 // General entry routine
154 //=============================================================================================
155 void generateWaitFor( std::list< Declaration * > & translationUnit ) {
156 GenerateWaitForPass ::implement( translationUnit );
157 }
158
159 //=============================================================================================
160 // Generic helper routine
161 //=============================================================================================
162
163 namespace {
164 Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) {
165 return new UntypedExpr(
166 new NameExpr( "?[?]" ),
167 {
168 new VariableExpr( array ),
169 new ConstantExpr( Constant::from_ulong( index ) )
170 }
171 );
172 }
173
174 Expression * makeOpAssign( Expression * lhs, Expression * rhs ) {
175 return new UntypedExpr(
176 new NameExpr( "?=?" ),
177 { lhs, rhs }
178 );
179 }
180
181 Expression * makeOpMember( Expression * sue, const std::string & mem ) {
182 return new UntypedMemberExpr( new NameExpr( mem ), sue );
183 }
184
185 Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
186 Expression * expr = makeOpAssign(
187 makeOpMember(
188 makeOpIndex(
189 object,
190 index
191 ),
192 member
193 ),
194 value
195 );
196
197 ResolvExpr::findVoidExpression( expr, indexer );
198
199 return new ExprStmt( expr );
200 }
201
202 Expression * safeCond( Expression * expr, bool ifnull = true ) {
203 if( expr ) return expr;
204
205 return new ConstantExpr( Constant::from_bool( ifnull ) );
206 }
207
208 VariableExpr * extractVariable( Expression * func ) {
209 if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) {
210 return var;
211 }
212
213 CastExpr * cast = strict_dynamic_cast< CastExpr * >( func );
214 return strict_dynamic_cast< VariableExpr * >( cast->arg );
215 }
216
217 Expression * detectIsDtor( Expression * func ) {
218 VariableExpr * typed_func = extractVariable( func );
219 bool is_dtor = InitTweak::isDestructor( typed_func->var );
220 return new ConstantExpr( Constant::from_bool( is_dtor ) );
221 }
222 };
223
224
225 //=============================================================================================
226 // Generate waitfor implementation
227 //=============================================================================================
228
229 void GenerateWaitForPass::premutate( FunctionDecl * decl) {
230 if( decl->name != "__waitfor_internal" ) return;
231
232 decl_waitfor = decl;
233 }
234
235 void GenerateWaitForPass::premutate( StructDecl * decl ) {
236 if( ! decl->body ) return;
237
238 if( decl->name == "__acceptable_t" ) {
239 assert( !decl_acceptable );
240 decl_acceptable = decl;
241 }
242 else if( decl->name == "__waitfor_mask_t" ) {
243 assert( !decl_mask );
244 decl_mask = decl;
245 }
246 else if( decl->name == "$monitor" ) {
247 assert( !decl_monitor );
248 decl_monitor = decl;
249 }
250 }
251
252 Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
253 if( !decl_monitor || !decl_acceptable || !decl_mask )
254 SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor.hfa>" );
255
256 CompoundStmt * stmt = new CompoundStmt();
257
258 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
259 ObjectDecl * flag = declareFlag( stmt );
260 Statement * setter = makeSetter( flag );
261
262 int index = 0;
263 for( auto & clause : waitfor->clauses ) {
264 init( acceptables, index, clause, setter, stmt );
265
266 index++;
267 }
268
269 Expression * timeout = init_timeout(
270 waitfor->timeout.time,
271 waitfor->timeout.condition,
272 waitfor->orelse .statement,
273 waitfor->orelse .condition,
274 setter,
275 stmt
276 );
277
278 CompoundStmt * compound = new CompoundStmt();
279 stmt->push_back( new IfStmt(
280 safeCond( new VariableExpr( flag ) ),
281 compound,
282 nullptr
283 ));
284
285 Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound );
286
287 choose( waitfor, result, compound );
288
289 return stmt;
290 }
291
292 ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt )
293 {
294 ObjectDecl * acceptables = ObjectDecl::newObject(
295 namer_acc.newName(),
296 new ArrayType(
297 noQualifiers,
298 new StructInstType(
299 noQualifiers,
300 decl_acceptable
301 ),
302 new ConstantExpr( Constant::from_ulong( count ) ),
303 false,
304 false
305 ),
306 nullptr
307 );
308
309 stmt->push_back( new DeclStmt( acceptables) );
310
311 Expression * set = new UntypedExpr(
312 new NameExpr( "__builtin_memset" ),
313 {
314 new VariableExpr( acceptables ),
315 new ConstantExpr( Constant::from_int( 0 ) ),
316 new SizeofExpr( new VariableExpr( acceptables ) )
317 }
318 );
319
320 ResolvExpr::findVoidExpression( set, indexer );
321
322 stmt->push_back( new ExprStmt( set ) );
323
324 return acceptables;
325 }
326
327 ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
328 ObjectDecl * flag = ObjectDecl::newObject(
329 namer_flg.newName(),
330 new BasicType(
331 noQualifiers,
332 BasicType::Bool
333 ),
334 new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
335 );
336
337 stmt->push_back( new DeclStmt( flag) );
338
339 return flag;
340 }
341
342 Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
343 Expression * expr = new UntypedExpr(
344 new NameExpr( "?=?" ),
345 {
346 new VariableExpr( flag ),
347 new ConstantExpr( Constant::from_ulong( 1 ) )
348 }
349 );
350
351 ResolvExpr::findVoidExpression( expr, indexer );
352
353 return new ExprStmt( expr );
354 }
355
356 ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
357
358 ObjectDecl * mon = ObjectDecl::newObject(
359 namer_mon.newName(),
360 new ArrayType(
361 noQualifiers,
362 new PointerType(
363 noQualifiers,
364 new StructInstType(
365 noQualifiers,
366 decl_monitor
367 )
368 ),
369 new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ),
370 false,
371 false
372 ),
373 new ListInit(
374 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
375 Expression * init = new CastExpr(
376 new UntypedExpr(
377 new NameExpr( "get_monitor" ),
378 { expr }
379 ),
380 new PointerType(
381 noQualifiers,
382 new StructInstType(
383 noQualifiers,
384 decl_monitor
385 )
386 )
387 );
388
389 ResolvExpr::findSingleExpression( init, indexer );
390 return new SingleInit( init );
391 })
392 )
393 );
394
395 stmt->push_back( new DeclStmt( mon) );
396
397 return mon;
398 }
399
400 void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
401
402 ObjectDecl * monitors = declMon( clause, stmt );
403
404 Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
405
406 stmt->push_back( new IfStmt(
407 safeCond( clause.condition ),
408 new CompoundStmt({
409 makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function ) , indexer ),
410 makeAccStatement( acceptables, index, "func" , new CastExpr( clause.target.function, fptr_t ) , indexer ),
411 makeAccStatement( acceptables, index, "data" , new VariableExpr( monitors ) , indexer ),
412 makeAccStatement( acceptables, index, "size" , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
413 setter->clone()
414 }),
415 nullptr
416 ));
417
418 clause.target.function = nullptr;
419 clause.target.arguments.empty();
420 clause.condition = nullptr;
421 }
422
423 Expression * GenerateWaitForPass::init_timeout(
424 Expression *& time,
425 Expression *& time_cond,
426 bool has_else,
427 Expression *& else_cond,
428 Statement * setter,
429 CompoundStmt * stmt
430 ) {
431 ObjectDecl * timeout = ObjectDecl::newObject(
432 namer_tim.newName(),
433 new BasicType(
434 noQualifiers,
435 BasicType::LongLongUnsignedInt
436 ),
437 new SingleInit(
438 new ConstantExpr( Constant::from_int( -1 ) )
439 )
440 );
441
442 stmt->push_back( new DeclStmt( timeout ) );
443
444 if( time ) {
445 stmt->push_back( new IfStmt(
446 safeCond( time_cond ),
447 new CompoundStmt({
448 new ExprStmt(
449 makeOpAssign(
450 new VariableExpr( timeout ),
451 time
452 )
453 ),
454 setter->clone()
455 }),
456 nullptr
457 ));
458
459 time = time_cond = nullptr;
460 }
461
462 if( has_else ) {
463 stmt->push_back( new IfStmt(
464 safeCond( else_cond ),
465 new CompoundStmt({
466 new ExprStmt(
467 makeOpAssign(
468 new VariableExpr( timeout ),
469 new ConstantExpr( Constant::from_ulong( 0 ) )
470 )
471 ),
472 setter->clone()
473 }),
474 nullptr
475 ));
476
477 else_cond = nullptr;
478 }
479
480 delete setter;
481
482 return new VariableExpr( timeout );
483 }
484
485 Expression * GenerateWaitForPass::call(
486 size_t count,
487 ObjectDecl * acceptables,
488 Expression * timeout,
489 CompoundStmt * stmt
490 ) {
491 ObjectDecl * index = ObjectDecl::newObject(
492 namer_idx.newName(),
493 new BasicType(
494 noQualifiers,
495 BasicType::ShortSignedInt
496 ),
497 new SingleInit(
498 new ConstantExpr( Constant::from_int( -1 ) )
499 )
500 );
501
502 stmt->push_back( new DeclStmt( index ) );
503
504 ObjectDecl * mask = ObjectDecl::newObject(
505 namer_msk.newName(),
506 new StructInstType(
507 noQualifiers,
508 decl_mask
509 ),
510 new ListInit({
511 new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
512 new ListInit({
513 new SingleInit( new VariableExpr( acceptables ) ),
514 new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
515 })
516 })
517 );
518
519 stmt->push_back( new DeclStmt( mask ) );
520
521 stmt->push_back( new ExprStmt(
522 new ApplicationExpr(
523 VariableExpr::functionPointer( decl_waitfor ),
524 {
525 new CastExpr(
526 new VariableExpr( mask ),
527 new ReferenceType(
528 noQualifiers,
529 new StructInstType(
530 noQualifiers,
531 decl_mask
532 )
533 )
534 ),
535 timeout
536 }
537 )
538 ));
539
540 return new VariableExpr( index );
541 }
542
543 void GenerateWaitForPass::choose(
544 WaitForStmt * waitfor,
545 Expression * result,
546 CompoundStmt * stmt
547 ) {
548 SwitchStmt * swtch = new SwitchStmt(
549 result,
550 std::list<Statement *>()
551 );
552
553 unsigned long i = 0;
554 for( auto & clause : waitfor->clauses ) {
555 swtch->statements.push_back(
556 new CaseStmt(
557 new ConstantExpr( Constant::from_ulong( i++ ) ),
558 {
559 new CompoundStmt({
560 clause.statement,
561 new BranchStmt(
562 "",
563 BranchStmt::Break
564 )
565 })
566 }
567 )
568 );
569 }
570
571 if(waitfor->timeout.statement) {
572 swtch->statements.push_back(
573 new CaseStmt(
574 new ConstantExpr( Constant::from_int( -2 ) ),
575 {
576 new CompoundStmt({
577 waitfor->timeout.statement,
578 new BranchStmt(
579 "",
580 BranchStmt::Break
581 )
582 })
583 }
584 )
585 );
586 }
587
588 if(waitfor->orelse.statement) {
589 swtch->statements.push_back(
590 new CaseStmt(
591 new ConstantExpr( Constant::from_int( -1 ) ),
592 {
593 new CompoundStmt({
594 waitfor->orelse.statement,
595 new BranchStmt(
596 "",
597 BranchStmt::Break
598 )
599 })
600 }
601 )
602 );
603 }
604
605 stmt->push_back( swtch );
606 }
607};
608
609// Local Variables: //
610// mode: c //
611// tab-width: 4 //
612// End: //
Note: See TracBrowser for help on using the repository browser.