source: src/Concurrency/Waitfor.cc@ f0ecf9b

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since f0ecf9b was 08da53d, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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