Studio:Restrictions on discriminated unions - Revision history

Timd: Text replace - 'Category:Unions' to 'Category:Studio:Unions'

2009-08-21T00:34:30Z

Text replace - 'Category:Unions' to 'Category:Studio:Unions'

← Older revision		Revision as of 00:34, 21 August 2009
Line 95:		Line 95:


	[[Category:Unions]]		[[Category:Studio:Unions]]

Timd: Restrictions on discriminated unions moved to Studio:Restrictions on discriminated unions

2009-08-18T23:16:17Z

Restrictions on discriminated unions moved to Studio:Restrictions on discriminated unions

← Older revision	Revision as of 23:16, 18 August 2009
(No difference)

Timd at 00:17, 11 March 2008

2008-03-11T00:17:45Z

Show changes

Timd at 18:45, 29 February 2008

2008-02-29T18:45:35Z

← Older revision		Revision as of 18:45, 29 February 2008
Line 81:		Line 81:


	[[Category:KB]]		[[Category:Unions]]

Root at 22:55, 21 June 2007

2007-06-21T22:55:32Z

← Older revision		Revision as of 22:55, 21 June 2007
Line 78:		Line 78:
	#pragma scl_ptr(f.pd, INOUT, PRIVATE)<br>		#pragma scl_ptr(f.pd, INOUT, PRIVATE)<br>
	#pragma scl_ptr(*f.pd, INRETURN, POOL) <br></tt>		#pragma scl_ptr(*f.pd, INRETURN, POOL) <br></tt>



			[[Category:KB]]

Root at 23:22, 12 June 2007

2007-06-12T23:22:45Z

← Older revision		Revision as of 23:22, 12 June 2007
Line 7:		Line 7:
	Within a payload (Command or Response), the discriminant may not reside in a payload memory block that is a descendent of the block in which the union resides. (See section 1.2.11 Payloads for a detailed description of memory blocks)<br>		Within a payload (Command or Response), the discriminant may not reside in a payload memory block that is a descendent of the block in which the union resides. (See section 1.2.11 Payloads for a detailed description of memory blocks)<br>

	'''Union/Discriminant Restriction #3: Discriminant may not reside in a memory block comes “after” the union'''<br>		'''Union/Discriminant Restriction #3: Discriminant may not reside in a memory block that comes “after” the union'''<br>
	Within a payload (Command or Response), the discrimiminant may not reside in a memory block that comes after the block containing the union given a pre-order, left, right traversal of memory blocks that make up the payload. (See section 1.2.11 Payloads for a detailed description of memory blocks)<br>		Within a payload (Command or Response), the discrimiminant may not reside in a memory block that comes after the block containing the union given a pre-order, left, right traversal of memory blocks that make up the payload. (See section 1.2.11 Payloads for a detailed description of memory blocks)<br>

Root at 23:20, 12 June 2007

2007-06-12T23:20:33Z

New page

Beginning with STRIDE 2.1, there are restrictions in place for disciminated unions. These restrictions are diagnosed as errors by the SCL language translator if they are encountered. 

'''Union/Discriminant Restriction #1: Union and Discriminant must reside in same payload''' 
The discriminant for a discriminated union must be present in the Command Payload if the union is present in the Command Payload. The discriminant for a discriminated union must be present in the Respose Payload if the union is present in the Response Payload. 

'''Union/Discriminant Restriction #2: Discriminant may not reside in a memory block that is a descendent of the block that contains the union.''' 
Within a payload (Command or Response), the discriminant may not reside in a payload memory block that is a descendent of the block in which the union resides. (See section 1.2.11 Payloads for a detailed description of memory blocks) 

'''Union/Discriminant Restriction #3: Discriminant may not reside in a memory block comes “after” the union''' 
Within a payload (Command or Response), the discrimiminant may not reside in a memory block that comes after the block containing the union given a pre-order, left, right traversal of memory blocks that make up the payload. (See section 1.2.11 Payloads for a detailed description of memory blocks) 

'''Union/Discriminant Restriction #4: Union residing in OUT block may not have discriminant residing in RETURN or INRETURN block''' 
'''Union/Discriminant Restriction #5: Union residing in INOUT block may not have discriminant that resides in INRETURN block 
'''''Rationale for the Restrictions''''' 

Restriction #1: To eliminate Restriction #1 the host runtime would need to capture and record discrimant values on a call so that on the corresponding return the values could recalled and used to discriminate the union value within the response payload (since the discriminant values cannot be found in the response payload).

Restrictions #2 thru #5 are in place because of the manner in which the host runtime processes I-blocks sent from target to host. The host runtime is designed to process each block fully before reading the next block. This means that the host runtime cannot handle the senario where the union resides in an I-block that arrives prior to the I-block containing the discriminant. 
'''Examples''' 
''Restricted by #1:''
<tt>typedef union U { int m1; int m2;} U; 
U f(int d); 
#pragma scl_function(f); 
#pragma scl_union(f(), f.d); </tt>
''Restricted by #1:''
<tt>typedef union U { int m1; int m2;} U; 
void f(int d, U* pu); 
#pragma scl_function(f); 
#pragma scl_union(*f.pu, f.d); 
#pragma scl_ptr(f.pu, OUT, PRIVATE) </tt>

''Restricted by #2:'' 
<tt>typedef union U { int m1; int m2;} U; 
typedef struct S 
{ 
int *pd; 
U u; 
}S ; 
void f(S s); 
#pragma scl_function(f); 
#pragma scl_union(f.s.u, *f.s.pd); </tt>

''Restricted by #2:'' 
<tt>typedef struct M1 { int *pd; int x;} M1; 
typedef struct M2 { int *pd; int y;} M2; 
typedef union U { M1 m1; M2 m2;} U; 
void f(U u); 
#pragma scl_function(f); 
#pragma scl_union(f.u, *f.u.m1.pd); </tt>

''Restricted by #3:''
<tt>typedef union U { int m1; int m2;} U; 
void f(U* pu, int *pd); 
#pragma scl_function(f); 
#pragma scl_union(*f.pu, *f.pd) </tt>

''NOT Restricted by #3 (or any other restriction)''
<tt>typedef union U { int m1; int m2;} U; 
void f(int *pd, U* pu); 
#pragma scl_function(f); 
#pragma scl_union(*f.pu, *f.pd) </tt>

''Restricted by #4''
<tt>typedef union U { int m1; int m2;} U; 
void f(int **pd, U* pu); 
#pragma scl_function(f) 
#pragma scl_union(*f.pu, **f.pd) 
#pragma scl_ptr(f.pu, OUT, PRIVATE) 
#pragma scl_ptr(f.pd, OUT, PRIVATE) 
#pragma scl_ptr(*f.pd, RETURN, POOL) </tt>

''Restricted by #5''
<tt>typedef union U { int m1; int m2;} U; 
void f(int **pd, U* pu); 
#pragma scl_function(f) 
#pragma scl_union(*f.pu, **f.pd) 
#pragma scl_ptr(f.pu, INOUT, PRIVATE) 
#pragma scl_ptr(f.pd, INOUT, PRIVATE) 
#pragma scl_ptr(*f.pd, INRETURN, POOL) </tt>