Context Navigation

source: src/Concurrency/Waitfor.cc @ d6566c1

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since d6566c1 was ac2b598, checked in by Thierry Delisle <tdelisle@…>, 5 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
21	using 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
40	class Attribute;
41	/*
42	void 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
52	void f(int i, float f, A & mutex b, struct foo * );
53	void f(int );
54
55
56	\| \|
57	\| \|
58	\| \|
59	\| \|
60	\| \|
61	\ \| \| /
62	\ /
63	\ /
64	\/
65
66
67	void 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
103	namespace 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.

Download in other formats: