Studio:Accessing target data while processing a proxy call - Revision history

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

2009-08-21T00:40:54Z

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

← Older revision		Revision as of 00:40, 21 August 2009
Line 68:		Line 68:
	</source>		</source>

	[[Category:Pointers]]		[[Category:Studio:Pointers]]

Timd: Accessing target data while processing a proxy call moved to Studio:Accessing target data while processing a proxy call

2009-08-18T23:24:27Z

Accessing target data while processing a proxy call moved to Studio:Accessing target data while processing a proxy call

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

Timd at 23:56, 10 March 2008

2008-03-10T23:56:15Z

← Older revision		Revision as of 23:56, 10 March 2008
Line 1:		Line 1:
	In some cases, void pointers are passed into proxy functions calls, or the passed structures are so complex that they cannot completely be described for STRIDE. In these cases, the proxy (e.g., a script) might have to access certain data on the target to be able to validate the functionality of the call. For example, this might be required with an interface that writes structured data to a file:<br>		In some cases, void pointers are passed into proxy functions calls, or the passed structures are so complex that they cannot completely be described for STRIDE. In these cases, the proxy (e.g., a script) might have to access certain data on the target to be able to validate the functionality of the call. For example, this might be required with an interface that writes structured data to a file:<br>
	<tt>int write(const void *buffer, int element_size, int count)</tt>		<source lang="c">
			int write(const void *buffer, int element_size, int count)
			</source>

	STRIDE needs to know the data structure in order to correctly marshal the data across platforms. The element size itself is not enough information for STRIDE. The buffer pointer could be typecast to a byte pointer; however, in this case the number of elements would be based on element size and count. STRIDE supports sized pointers, as long as the size is a single field and not the combination of multiple fields.		STRIDE needs to know the data structure in order to correctly marshal the data across platforms. The element size itself is not enough information for STRIDE. The buffer pointer could be typecast to a byte pointer; however, in this case the number of elements would be based on element size and count. STRIDE supports sized pointers, as long as the size is a single field and not the combination of multiple fields.
Line 6:		Line 8:
	How can an interface like this be easily dealt with in STRIDE if we plan on testing an application which uses this interface, but the library which implements the functionality is not yet available?		How can an interface like this be easily dealt with in STRIDE if we plan on testing an application which uses this interface, but the library which implements the functionality is not yet available?

	First of all, the assumption is the actual structure is of no interest. We simply want to test the ability to write to a stream and later read from it, and verify we get the same data back. In this case, we can leave the buffer pointer as a void pointer and just pass the void pointer to STRIDE. Once in the proxy function, we need a way to retrieve the actual data at this pointer address from the target; this can be done with a helper function which reads a number of bytes from a certain memory address and passes it back to STRIDE. A simple helper function in the .h file perform this function:<br>		First of all, the assumption is the actual structure is of no interest. We simply want to test the ability to write to a stream and later read from it, and verify we get the same data back. In this case, we can leave the buffer pointer as a void pointer and just pass the void pointer to STRIDE. Once in the proxy function, we need a way to retrieve the actual data at this pointer address from the target; this can be done with a helper function which reads a number of bytes from a certain memory address and passes it back to STRIDE. A simple helper function in the .h file perform this function:
	~~<tt>~~static void SCL_get_num_bytes(void ptr, unsigned char data, int num_bytes)
	{		<source lang="c">
	memcpy(data, ptr, num_bytes);		static void SCL_get_num_bytes(void ptr, unsigned char data, int num_bytes)
	}</tt>		{
			memcpy(data, ptr, num_bytes);
			}
			</source>

	An important note is that the data has to be valid when the helper function is called. In the case of a proxy call, the pointer should certainly be valid until the function returns. The proxy script is as follows:		An important note is that the data has to be valid when the helper function is called. In the case of a proxy call, the pointer should certainly be valid until the function returns. The proxy script is as follows:
	write.owner.register event = ascript.WaitForEvent();		<source lang="javascript">
	if (event = write)		write.owner.register();
	{		var event = ascript.WaitForEvent();
	/* Copy the buffer pointer from the proxy call */		if (event == write)
	scl_get_num_bytes.ParameterList.num_bytes = write.ParameterList.element_size *write.ParameterList.count;		{
			/* Copy the buffer pointer from the proxy call */
			scl_get_num_bytes.ParameterList.num_bytes = write.ParameterList.element_size * write.ParameterList.count;

	/* Call the helper function to retrieve the data */		/* Call the helper function to retrieve the data */
	scl_get_num_bytes.Call();		scl_get_num_bytes.Call();

	/* Process the data */		/* Process the data */
	get_num_bytes.User.OutPointers.data ... ...		get_num_bytes.User.OutPointers.data ... ...

	write.Return();		write.Return();
	/* return from the proxy function call */		/* return from the proxy function call */
	}		}
			</source>

	The same can be done for the read function. Once the read proxy is called, a helper function can be called to copy the actual data in place. The read interface is as follows:		The same can be done for the read function. Once the read proxy is called, a helper function can be called to copy the actual data in place. The read interface is as follows:

	int read(void *buffer, int element_size, int count);		<source lang="c">
	static void SCL_set_num_bytes(void ptr, unsigned char data, int num_bytes)		int read(void *buffer, int element_size, int count);
	{		static void SCL_set_num_bytes(void ptr, unsigned char data, int num_bytes)
	memcpy(ptr, data, num_bytes);		{
	}		memcpy(ptr, data, num_bytes);
	read.owner.register event = ascript.WaitForEvent();		}
	if (event = read)		</source>
	{		<source lang="javascript">
	/* set the data to be read */		read.owner.register();
	set_num_bytes.User.ParameterList.data = ... ...		var event = ascript.WaitForEvent();
			if (event == read)
			{
			/* set the data to be read */
			set_num_bytes.User.ParameterList.data = ... ...

	/* copy the buffer pointer from the proxy call */		/* copy the buffer pointer from the proxy call */
	scl_set_num_bytes.ParameterList.ptr = read.ParameterList.buffer;		scl_set_num_bytes.ParameterList.ptr = read.ParameterList.buffer;

	/* calculate the number of bytes */		/* calculate the number of bytes */
	scl_set_num_bytes.ParameterList.num_bytes = read.ParameterList.element_size *read.ParameterList.count;		scl_set_num_bytes.ParameterList.num_bytes = read.ParameterList.element_size *read.ParameterList.count;

	/* Call the helper function to retrieve the data */		/* Call the helper function to retrieve the data */
	scl_set_num_bytes.Call();		scl_set_num_bytes.Call();

	/* Process the data */		/* Process the data */
	read.Return(); /* return from the proxy function call */		read.Return(); /* return from the proxy function call */
	}		}
			</source>

	[[Category:Pointers]]		[[Category:Pointers]]

Timd at 18:00, 29 February 2008

2008-02-29T18:00:01Z

← Older revision		Revision as of 18:00, 29 February 2008
Line 54:		Line 54:
	read.Return(); /* return from the proxy function call */		read.Return(); /* return from the proxy function call */
	}		}
			[[Category:Pointers]]

Root at 20:48, 5 February 2008

2008-02-05T20:48:08Z

← Older revision		Revision as of 20:48, 5 February 2008
Line 54:		Line 54:
	read.Return(); /* return from the proxy function call */		read.Return(); /* return from the proxy function call */
	}		}


	~~[[Category:Application Notes]]~~

Root at 23:29, 4 February 2008

2008-02-04T23:29:44Z

← Older revision		Revision as of 23:29, 4 February 2008
Line 56:		Line 56:


	~~[[Category:SCL]]~~[[Category:Application Notes]]		[[Category:Application Notes]]

Root at 21:32, 4 February 2008

2008-02-04T21:32:17Z

← Older revision		Revision as of 21:32, 4 February 2008
Line 56:		Line 56:


	[[Category:SCL]][[Category:~~AppNotes~~]]		[[Category:SCL]][[Category:Application Notes]]

Root at 21:31, 4 February 2008

2008-02-04T21:31:53Z

← Older revision		Revision as of 21:31, 4 February 2008
Line 56:		Line 56:


	[[Category:SCL]]		[[Category:SCL]][[Category:AppNotes]]

Robg at 17:06, 1 February 2008

2008-02-01T17:06:08Z

← Older revision		Revision as of 17:06, 1 February 2008
Line 18:		Line 18:
	/* Copy the buffer pointer from the proxy call */		/* Copy the buffer pointer from the proxy call */
	scl_get_num_bytes.ParameterList.num_bytes = write.ParameterList.element_size *write.ParameterList.count;		scl_get_num_bytes.ParameterList.num_bytes = write.ParameterList.element_size *write.ParameterList.count;

	/* Call the helper function to retrieve the data */		/* Call the helper function to retrieve the data */
	scl_get_num_bytes.Call();		scl_get_num_bytes.Call();

	/* Process the data */		/* Process the data */
	get_num_bytes.User.OutPointers.data ... ...		get_num_bytes.User.OutPointers.data ... ...

	write.Return();		write.Return();
	/* return from the proxy function call */		/* return from the proxy function call */

Robg at 17:05, 1 February 2008

2008-02-01T17:05:56Z

← Older revision		Revision as of 17:05, 1 February 2008
Line 30:		Line 30:

	The same can be done for the read function. Once the read proxy is called, a helper function can be called to copy the actual data in place. The read interface is as follows:		The same can be done for the read function. Once the read proxy is called, a helper function can be called to copy the actual data in place. The read interface is as follows:
	~~<tt>~~int read(void *buffer, int element_size, int count);
	static void SCL_set_num_bytes(void ptr, unsigned char data, int num_bytes)~~<br>~~		int read(void *buffer, int element_size, int count);
	{~~<br>~~		static void SCL_set_num_bytes(void ptr, unsigned char data, int num_bytes)
	memcpy(ptr, data, num_bytes);~~<br>~~		{
	}~~<br><br>~~		memcpy(ptr, data, num_bytes);
	read.owner.register event = ascript.WaitForEvent();		}
	if (event = read)~~<br>~~		read.owner.register event = ascript.WaitForEvent();
	{~~<br>~~		if (event = read)
	/* set the data to be read */~~<br>~~		{
	set_num_bytes.User.ParameterList.data = ... ... ~~<br>~~		/* set the data to be read */
	/* copy the buffer pointer from the proxy call */ ~~<br>~~		set_num_bytes.User.ParameterList.data = ... ...
	scl_set_num_bytes.ParameterList.ptr = read.ParameterList.buffer;~~<br>~~
	/* calculate the number of bytes */ ~~<br>~~		/* copy the buffer pointer from the proxy call */
	scl_set_num_bytes.ParameterList.num_bytes = read.ParameterList.element_size *read.ParameterList.count; ~~<br>~~		scl_set_num_bytes.ParameterList.ptr = read.ParameterList.buffer;
	/* Call the helper function to retrieve the data */ ~~<br>~~
	scl_set_num_bytes.Call(); ~~<br>~~		/* calculate the number of bytes */
	/* Process the data */ ~~<br>~~		scl_set_num_bytes.ParameterList.num_bytes = read.ParameterList.element_size *read.ParameterList.count;
	read.Return(); /* return from the proxy function call */~~<br>~~
	}		/* Call the helper function to retrieve the data */
			scl_set_num_bytes.Call();

			/* Process the data */
			read.Return(); /* return from the proxy function call */
			}


	[[Category:SCL]]		[[Category:SCL]]