source: src/Concurrency/Waitfor.cc@ b738974

ADT ast-experimental pthread-emulation qualifiedEnum
Last change on this file since b738974 was 08e4e6a, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Removed warning after last change.
  • Property mode set to 100644
File size: 15.0 KB
RevLine 
[9f5ecf5]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 :
[cca568e]13// Update Count : 12
[9f5ecf5]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
[312029a]25#include "Common/UniqueName.h" // for UniqueName
[9f5ecf5]26#include "Common/utility.h" // for deleteAll, map_range
27#include "CodeGen/OperatorTable.h" // for isConstructor
28#include "InitTweak/InitTweak.h" // for getPointerBase
[1dcd9554]29#include "ResolvExpr/Resolver.h" // for findVoidExpression
[07de76b]30#include "SynTree/LinkageSpec.h" // for Cforall
[9f5ecf5]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 ) {
[cca568e]44 when( a < 1 ) waitfor( f : a ) { bar(); }
[9f5ecf5]45 or timeout( swagl() );
[cca568e]46 or waitfor( g : a ) { baz(); }
47 or waitfor( ^?{} : a ) { break; }
[9f5ecf5]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 ) {
[42506e1]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;
[9f5ecf5]77
[42506e1]78 acceptables[2].func = f;
79 acceptables[2].mon = a;
80 acceptables[2].is_dtor = true;
[9f5ecf5]81
[42506e1]82 int ret = waitfor_internal( acceptables, swagl() );
[9f5ecf5]83
[42506e1]84 switch( ret ) {
85 case 0:
86 {
87 bar();
88 }
89 case 1:
[9f5ecf5]90 {
[42506e1]91 baz();
[9f5ecf5]92 }
[42506e1]93 case 2:
94 signal(a);
95 {
96 break;
97 }
98 }
[9f5ecf5]99 }
100 }
101}*/
102
103namespace Concurrency {
104 //=============================================================================================
105 // Pass declarations
106 //=============================================================================================
107
[1dcd9554]108 class GenerateWaitForPass final : public WithIndexer {
[9f5ecf5]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 );
[aaa4f93]122 ObjectDecl * declareFlag( CompoundStmt * stmt );
123 Statement * makeSetter( ObjectDecl * flag );
[9f5ecf5]124 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
[aaa4f93]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 );
[1dcd9554]127 Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
128 void choose( WaitForStmt * waitfor, Expression * result, CompoundStmt * stmt );
[9f5ecf5]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;
[aaa4f93]138 StructDecl * decl_mask = nullptr;
[9f5ecf5]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;
[aaa4f93]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;
[9f5ecf5]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 ) {
[1dcd9554]165 return new UntypedExpr(
[9f5ecf5]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 ) {
[1dcd9554]175 return new UntypedExpr(
[9f5ecf5]176 new NameExpr( "?=?" ),
177 { lhs, rhs }
178 );
179 }
180
[1dcd9554]181 Expression * makeOpMember( Expression * sue, const std::string & mem ) {
182 return new UntypedMemberExpr( new NameExpr( mem ), sue );
[9f5ecf5]183 }
184
[1dcd9554]185 Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
[08da53d]186 Expression * expr = makeOpAssign(
[1dcd9554]187 makeOpMember(
188 makeOpIndex(
189 object,
190 index
[9f5ecf5]191 ),
[1dcd9554]192 member
193 ),
194 value
[08da53d]195 );
196
197 ResolvExpr::findVoidExpression( expr, indexer );
[1dcd9554]198
[ba3706f]199 return new ExprStmt( expr );
[9f5ecf5]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 }
[310e5b7]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
[8f98b78]217 Expression * detectIsDtor( Expression * func ) {
[310e5b7]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 }
[9f5ecf5]222 };
223
224
225 //=============================================================================================
226 // Generate waitfor implementation
227 //=============================================================================================
228
229 void GenerateWaitForPass::premutate( FunctionDecl * decl) {
[310e5b7]230 if( decl->name != "__waitfor_internal" ) return;
[9f5ecf5]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 }
[aaa4f93]242 else if( decl->name == "__waitfor_mask_t" ) {
243 assert( !decl_mask );
244 decl_mask = decl;
245 }
[7f62b708]246 else if( decl->name == "monitor$" ) {
[9f5ecf5]247 assert( !decl_monitor );
248 decl_monitor = decl;
249 }
250 }
251
252 Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
[d55d7a6]253 if( !decl_monitor || !decl_acceptable || !decl_mask )
[73abe95]254 SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor.hfa>" );
[9f5ecf5]255
[ba3706f]256 CompoundStmt * stmt = new CompoundStmt();
[9f5ecf5]257
258 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
[aaa4f93]259 ObjectDecl * flag = declareFlag( stmt );
260 Statement * setter = makeSetter( flag );
[9f5ecf5]261
262 int index = 0;
263 for( auto & clause : waitfor->clauses ) {
[aaa4f93]264 init( acceptables, index, clause, setter, stmt );
[9f5ecf5]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,
[aaa4f93]274 setter,
[9f5ecf5]275 stmt
276 );
277
[ba3706f]278 CompoundStmt * compound = new CompoundStmt();
[aaa4f93]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 );
[9f5ecf5]286
[aaa4f93]287 choose( waitfor, result, compound );
[9f5ecf5]288
289 return stmt;
290 }
291
292 ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt )
293 {
[1dcd9554]294 ObjectDecl * acceptables = ObjectDecl::newObject(
[9f5ecf5]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
[ba3706f]309 stmt->push_back( new DeclStmt( acceptables) );
[9f5ecf5]310
[08da53d]311 Expression * set = new UntypedExpr(
[aaa4f93]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
[08da53d]320 ResolvExpr::findVoidExpression( set, indexer );
[aaa4f93]321
[ba3706f]322 stmt->push_back( new ExprStmt( set ) );
[aaa4f93]323
[9f5ecf5]324 return acceptables;
325 }
326
[aaa4f93]327 ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
328 ObjectDecl * flag = ObjectDecl::newObject(
329 namer_flg.newName(),
330 new BasicType(
331 noQualifiers,
[e15853c]332 BasicType::Bool
[aaa4f93]333 ),
334 new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
335 );
336
[ba3706f]337 stmt->push_back( new DeclStmt( flag) );
[aaa4f93]338
339 return flag;
340 }
341
342 Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
[08da53d]343 Expression * expr = new UntypedExpr(
[aaa4f93]344 new NameExpr( "?=?" ),
345 {
346 new VariableExpr( flag ),
347 new ConstantExpr( Constant::from_ulong( 1 ) )
348 }
349 );
350
[08da53d]351 ResolvExpr::findVoidExpression( expr, indexer );
[aaa4f93]352
[ba3706f]353 return new ExprStmt( expr );
[aaa4f93]354 }
355
[9f5ecf5]356 ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
357
[1dcd9554]358 ObjectDecl * mon = ObjectDecl::newObject(
[9f5ecf5]359 namer_mon.newName(),
360 new ArrayType(
361 noQualifiers,
[8f98b78]362 new PointerType(
[9f5ecf5]363 noQualifiers,
[8f98b78]364 new StructInstType(
365 noQualifiers,
366 decl_monitor
367 )
[9f5ecf5]368 ),
369 new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ),
370 false,
371 false
372 ),
373 new ListInit(
[08e4e6a]374 map_range < std::list<Initializer*> > ( clause.target.arguments, [](Expression * expr ){
[6668a3e]375 return new SingleInit( expr );
[9f5ecf5]376 })
377 )
378 );
379
[ba3706f]380 stmt->push_back( new DeclStmt( mon) );
[9f5ecf5]381
382 return mon;
383 }
384
[aaa4f93]385 void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
[9f5ecf5]386
387 ObjectDecl * monitors = declMon( clause, stmt );
388
[1dcd9554]389 Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
390
[9f5ecf5]391 stmt->push_back( new IfStmt(
392 safeCond( clause.condition ),
[aaa4f93]393 new CompoundStmt({
394 makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function ) , indexer ),
[b81fd95]395 makeAccStatement( acceptables, index, "func" , new CastExpr( clause.target.function, fptr_t, false ) , indexer ),
[0cf5b79]396 makeAccStatement( acceptables, index, "data" , new VariableExpr( monitors ) , indexer ),
[aaa4f93]397 makeAccStatement( acceptables, index, "size" , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
398 setter->clone()
399 }),
[9f5ecf5]400 nullptr
401 ));
402
403 clause.target.function = nullptr;
404 clause.target.arguments.empty();
405 clause.condition = nullptr;
406 }
407
408 Expression * GenerateWaitForPass::init_timeout(
409 Expression *& time,
410 Expression *& time_cond,
411 bool has_else,
412 Expression *& else_cond,
[aaa4f93]413 Statement * setter,
[9f5ecf5]414 CompoundStmt * stmt
415 ) {
[1dcd9554]416 ObjectDecl * timeout = ObjectDecl::newObject(
[9f5ecf5]417 namer_tim.newName(),
418 new BasicType(
419 noQualifiers,
420 BasicType::LongLongUnsignedInt
421 ),
422 new SingleInit(
423 new ConstantExpr( Constant::from_int( -1 ) )
424 )
425 );
426
[ba3706f]427 stmt->push_back( new DeclStmt( timeout ) );
[9f5ecf5]428
429 if( time ) {
430 stmt->push_back( new IfStmt(
[1dcd9554]431 safeCond( time_cond ),
[aaa4f93]432 new CompoundStmt({
433 new ExprStmt(
434 makeOpAssign(
435 new VariableExpr( timeout ),
436 time
437 )
438 ),
439 setter->clone()
440 }),
[9f5ecf5]441 nullptr
442 ));
443
444 time = time_cond = nullptr;
445 }
446
447 if( has_else ) {
448 stmt->push_back( new IfStmt(
449 safeCond( else_cond ),
[aaa4f93]450 new CompoundStmt({
451 new ExprStmt(
452 makeOpAssign(
453 new VariableExpr( timeout ),
454 new ConstantExpr( Constant::from_ulong( 0 ) )
455 )
456 ),
457 setter->clone()
458 }),
[9f5ecf5]459 nullptr
460 ));
461
462 else_cond = nullptr;
463 }
464
[aaa4f93]465 delete setter;
466
[9f5ecf5]467 return new VariableExpr( timeout );
468 }
[1dcd9554]469
470 Expression * GenerateWaitForPass::call(
471 size_t count,
472 ObjectDecl * acceptables,
473 Expression * timeout,
474 CompoundStmt * stmt
475 ) {
[aaa4f93]476 ObjectDecl * index = ObjectDecl::newObject(
477 namer_idx.newName(),
[1dcd9554]478 new BasicType(
479 noQualifiers,
[aaa4f93]480 BasicType::ShortSignedInt
[1dcd9554]481 ),
482 new SingleInit(
[aaa4f93]483 new ConstantExpr( Constant::from_int( -1 ) )
[1dcd9554]484 )
485 );
486
[ba3706f]487 stmt->push_back( new DeclStmt( index ) );
[aaa4f93]488
489 ObjectDecl * mask = ObjectDecl::newObject(
490 namer_msk.newName(),
491 new StructInstType(
492 noQualifiers,
493 decl_mask
494 ),
495 new ListInit({
496 new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
[d2d50d7]497 new ListInit({
498 new SingleInit( new VariableExpr( acceptables ) ),
499 new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
500 })
[aaa4f93]501 })
502 );
503
[ba3706f]504 stmt->push_back( new DeclStmt( mask ) );
[aaa4f93]505
506 stmt->push_back( new ExprStmt(
507 new ApplicationExpr(
508 VariableExpr::functionPointer( decl_waitfor ),
509 {
510 new CastExpr(
511 new VariableExpr( mask ),
512 new ReferenceType(
513 noQualifiers,
514 new StructInstType(
515 noQualifiers,
516 decl_mask
517 )
[b81fd95]518 ),
519 false
[aaa4f93]520 ),
521 timeout
522 }
523 )
524 ));
[1dcd9554]525
[aaa4f93]526 return new VariableExpr( index );
[1dcd9554]527 }
528
529 void GenerateWaitForPass::choose(
530 WaitForStmt * waitfor,
531 Expression * result,
532 CompoundStmt * stmt
533 ) {
534 SwitchStmt * swtch = new SwitchStmt(
535 result,
536 std::list<Statement *>()
537 );
538
539 unsigned long i = 0;
540 for( auto & clause : waitfor->clauses ) {
541 swtch->statements.push_back(
542 new CaseStmt(
543 new ConstantExpr( Constant::from_ulong( i++ ) ),
544 {
[42506e1]545 new CompoundStmt({
546 clause.statement,
547 new BranchStmt(
548 "",
549 BranchStmt::Break
550 )
551 })
[1dcd9554]552 }
553 )
554 );
555 }
556
557 if(waitfor->timeout.statement) {
558 swtch->statements.push_back(
559 new CaseStmt(
[b18830e]560 new ConstantExpr( Constant::from_int( -2 ) ),
[1dcd9554]561 {
[42506e1]562 new CompoundStmt({
563 waitfor->timeout.statement,
564 new BranchStmt(
565 "",
566 BranchStmt::Break
567 )
568 })
[1dcd9554]569 }
570 )
571 );
572 }
573
574 if(waitfor->orelse.statement) {
575 swtch->statements.push_back(
576 new CaseStmt(
[b18830e]577 new ConstantExpr( Constant::from_int( -1 ) ),
[1dcd9554]578 {
[42506e1]579 new CompoundStmt({
580 waitfor->orelse.statement,
581 new BranchStmt(
582 "",
583 BranchStmt::Break
584 )
585 })
[1dcd9554]586 }
587 )
588 );
589 }
590
591 stmt->push_back( swtch );
592 }
[9f5ecf5]593};
594
595// Local Variables: //
596// mode: c //
597// tab-width: 4 //
[08da53d]598// End: //
Note: See TracBrowser for help on using the repository browser.