URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [tmtests/] [tm20/] [task1.c] - Blame information for rev 609

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *
 *  COPYRIGHT (c) 1989-1999.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.OARcorp.com/rtems/license.html.
 *
 *  $Id: task1.c,v 1.2 2001-09-27 12:02:43 chris Exp $
 */
 
#define TEST_INIT
#include "system.h"
#include <assert.h>
 
rtems_device_major_number _STUB_major = 1;
 
rtems_id         Region_id;
rtems_name       Region_name;
rtems_unsigned8  Region_area[ 2048 ] CPU_STRUCTURE_ALIGNMENT;
 
#define PARTITION_SIZE         2048
#define PARTITION_ELEMENT_SIZE  128
#define PARTITION_BUFFER_POINTERS \
    ((PARTITION_SIZE / PARTITION_ELEMENT_SIZE) + 2)
 
rtems_id         Partition_id;
rtems_name       Partition_name;
rtems_unsigned8  Partition_area[ PARTITION_SIZE ] CPU_STRUCTURE_ALIGNMENT;
 
void  *Buffer_address_1;
void  *Buffer_address_2;
void  *Buffer_address_3;
void  *Buffer_address_4;
 
rtems_unsigned32 buffer_count;
 
void  *Buffer_addresses[ PARTITION_BUFFER_POINTERS ];
 
rtems_task Task_1(
  rtems_task_argument argument
);
 
rtems_task Task_2(
  rtems_task_argument argument
);
 
rtems_task Init(
  rtems_task_argument argument
)
{
  rtems_status_code status;
 
  Print_Warning();
 
  puts( "\n\n*** TIME TEST 20 ***" );
 
  status = rtems_task_create(
    rtems_build_name( 'T', 'I', 'M', '1' ),
    128,
    RTEMS_MINIMUM_STACK_SIZE,
    RTEMS_DEFAULT_MODES,
    RTEMS_DEFAULT_ATTRIBUTES,
    &Task_id[ 1 ]
  );
  directive_failed( status, "rtems_task_create of TASK1" );
 
  status = rtems_task_start( Task_id[ 1 ], Task_1, 0 );
  directive_failed( status, "rtems_task_start of TASK1" );
 
  status = rtems_task_create(
    rtems_build_name( 'T', 'I', 'M', '2' ),
    129,
    RTEMS_MINIMUM_STACK_SIZE,
    RTEMS_DEFAULT_MODES,
    RTEMS_DEFAULT_ATTRIBUTES,
    &Task_id[ 2 ]
  );
  directive_failed( status, "rtems_task_create of TASK2" );
 
  status = rtems_task_start( Task_id[ 2 ], Task_2, 0 );
  directive_failed( status, "rtems_task_start of TASK2" );
 
  status = rtems_task_delete( RTEMS_SELF );
  directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
 
rtems_task Task_1(
  rtems_task_argument argument
)
{
  rtems_unsigned32    index;
  rtems_mode          previous_mode;
  rtems_task_priority previous_priority;
  rtems_status_code   status;
 
  Partition_name = rtems_build_name( 'P', 'A', 'R', 'T' );
 
  Timer_initialize();
    rtems_partition_create(
      Partition_name,
      Partition_area,
      PARTITION_SIZE,
      128,
      RTEMS_DEFAULT_ATTRIBUTES,
      &Partition_id
    );
  end_time = Read_timer();
 
  put_time(
    "rtems_partition_create",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_PARTITION_CREATE
  );
 
  Region_name = rtems_build_name( 'R', 'E', 'G', 'N' );
 
  Timer_initialize();
    rtems_region_create(
      Region_name,
      Region_area,
      2048,
      16,
      RTEMS_DEFAULT_ATTRIBUTES,
      &Region_id
    );
  end_time = Read_timer();
 
  put_time(
    "rtems_region_create",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_CREATE
  );
 
  Timer_initialize();
    (void) rtems_partition_get_buffer( Partition_id, &Buffer_address_1 );
  end_time = Read_timer();
 
  put_time(
    "rtems_partition_get_buffer: available",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_PARTITION_GET_BUFFER
  );
 
  buffer_count = 0;
  while ( FOREVER ) {
 
    status = rtems_partition_get_buffer(
               Partition_id,
               &Buffer_addresses[ buffer_count ]
            );
 
    if ( status == RTEMS_UNSATISFIED ) break;
 
    buffer_count++;
 
    assert( buffer_count < PARTITION_BUFFER_POINTERS );
  }
 
  Timer_initialize();
    (void) rtems_partition_get_buffer( Partition_id, &Buffer_address_2 );
  end_time = Read_timer();
 
  put_time(
    "rtems_partition_get_buffer: not available",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_PARTITION_GET_BUFFER
  );
 
  Timer_initialize();
    (void) rtems_partition_return_buffer( Partition_id, Buffer_address_1 );
  end_time = Read_timer();
 
  put_time(
    "rtems_partition_return_buffer",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_PARTITION_RETURN_BUFFER
  );
 
  for ( index = 0 ; index < buffer_count ; index++ ) {
 
    status = rtems_partition_return_buffer(
               Partition_id,
               Buffer_addresses[ index ]
             );
    directive_failed( status, "rtems_partition_return_buffer" );
 
  }
 
  Timer_initialize();
    (void) rtems_partition_delete( Partition_id );
  end_time = Read_timer();
 
  put_time(
    "rtems_partition_delete",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_PARTITION_DELETE
  );
 
  status = rtems_region_get_segment(
             Region_id,
             400,
             RTEMS_DEFAULT_OPTIONS,
             RTEMS_NO_TIMEOUT,
             &Buffer_address_2
           );
  directive_failed( status, "region_get_segment" );
 
  Timer_initialize();
    (void) rtems_region_get_segment(
      Region_id,
      400,
      RTEMS_DEFAULT_OPTIONS,
      RTEMS_NO_TIMEOUT,
      &Buffer_address_3
    );
  end_time = Read_timer();
 
  put_time(
    "rtems_region_get_segment: available",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_GET_SEGMENT
  );
 
  Timer_initialize();
    (void) rtems_region_get_segment(
      Region_id,
      1998,
      RTEMS_NO_WAIT,
      RTEMS_NO_TIMEOUT,
      &Buffer_address_4
    );
  end_time = Read_timer();
 
  put_time(
    "rtems_region_get_segment: not available -- NO_WAIT",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_GET_SEGMENT
  );
 
  status = rtems_region_return_segment( Region_id, Buffer_address_3 );
  directive_failed( status, "rtems_region_return_segment" );
 
  Timer_initialize();
    (void) rtems_region_return_segment( Region_id, Buffer_address_2 );
  end_time = Read_timer();
 
  put_time(
    "rtems_region_return_segment: no waiting tasks",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_RETURN_SEGMENT
  );
 
  status = rtems_region_get_segment(
    Region_id,
    400,
    RTEMS_DEFAULT_OPTIONS,
    RTEMS_NO_TIMEOUT,
    &Buffer_address_1
  );
  directive_failed( status, "rtems_region_get_segment" );
 
  Timer_initialize();
    (void) rtems_region_get_segment(
      Region_id,
      1998,
      RTEMS_DEFAULT_OPTIONS,
      RTEMS_NO_TIMEOUT,
      &Buffer_address_2
    );
 
  /* execute Task_2 */
 
  end_time = Read_timer();
 
  put_time(
    "rtems_region_return_segment: task readied -- preempts caller",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_RETURN_SEGMENT
  );
 
  status = rtems_region_return_segment( Region_id, Buffer_address_2 );
  directive_failed( status, "rtems_region_return_segment" );
 
  status = rtems_task_mode(
    RTEMS_NO_PREEMPT,
    RTEMS_PREEMPT_MASK,
    &previous_mode
  );
  directive_failed( status, "rtems_task_mode" );
 
  status = rtems_task_set_priority( RTEMS_SELF, 254, &previous_priority );
  directive_failed( status, "rtems_task_set_priority" );
 
  status = rtems_region_get_segment(
    Region_id,
    400,
    RTEMS_DEFAULT_OPTIONS,
    RTEMS_NO_TIMEOUT,
    &Buffer_address_1
  );
  directive_failed( status, "rtems_region_return_segment" );
 
  status = rtems_region_get_segment(
    Region_id,
    1998,
    RTEMS_DEFAULT_OPTIONS,
    RTEMS_NO_TIMEOUT,
    &Buffer_address_2
  );
  directive_failed( status, "rtems_region_get_segment" );
 
  /* execute Task_2 */
 
  status = rtems_region_return_segment( Region_id, Buffer_address_2 );
  directive_failed( status, "rtems_region_return_segment" );
 
  Timer_initialize();
    (void) rtems_region_delete( Region_id );
  end_time = Read_timer();
 
  put_time(
    "rtems_region_delete",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_DELETE
  );
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) Empty_function();
  overhead = Read_timer();
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) rtems_io_initialize( _STUB_major, 0, NULL );
  end_time = Read_timer();
 
  put_time(
    "rtems_io_initialize",
    end_time,
    OPERATION_COUNT,
    overhead,
    CALLING_OVERHEAD_IO_INITIALIZE
  );
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) rtems_io_open( _STUB_major, 0, NULL );
  end_time = Read_timer();
 
  put_time(
    "rtems_io_open",
    end_time,
    OPERATION_COUNT,
    overhead,
    CALLING_OVERHEAD_IO_OPEN
  );
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) rtems_io_close( _STUB_major, 0, NULL );
  end_time = Read_timer();
 
  put_time(
    "rtems_io_close",
    end_time,
    OPERATION_COUNT,
    overhead,
    CALLING_OVERHEAD_IO_CLOSE
  );
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) rtems_io_read( _STUB_major, 0, NULL );
  end_time = Read_timer();
 
  put_time(
    "rtems_io_read",
    end_time,
    OPERATION_COUNT,
    overhead,
    CALLING_OVERHEAD_IO_READ
  );
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) rtems_io_write( _STUB_major, 0, NULL );
  end_time = Read_timer();
 
  put_time(
    "rtems_io_write",
    end_time,
    OPERATION_COUNT,
    overhead,
    CALLING_OVERHEAD_IO_WRITE
  );
 
  Timer_initialize();
    for ( index=1 ; index <= OPERATION_COUNT ; index++ )
      (void) rtems_io_control( _STUB_major, 0, NULL );
  end_time = Read_timer();
 
  put_time(
    "rtems_io_control",
    end_time,
    OPERATION_COUNT,
    overhead,
    CALLING_OVERHEAD_IO_CONTROL
  );
 
  puts( "*** END OF TEST 20 ***" );
  exit( 0 );
}
 
rtems_task Task_2(
  rtems_task_argument argument
)
{
  rtems_status_code status;
 
  end_time = Read_timer();
 
  put_time(
    "rtems_region_get_segment: not available -- caller blocks",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_GET_SEGMENT
  );
 
  Timer_initialize();
    (void) rtems_region_return_segment( Region_id, Buffer_address_1 );
 
  /* preempt back to Task_1 */
 
  Timer_initialize();
    (void) rtems_region_return_segment( Region_id, Buffer_address_1 );
  end_time = Read_timer();
 
  put_time(
    "rtems_region_return_segment: task readied -- returns to caller",
    end_time,
    1,
    0,
    CALLING_OVERHEAD_REGION_RETURN_SEGMENT
  );
 
  status = rtems_task_delete( RTEMS_SELF );
  directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [tmtests/] [tm20/] [task1.c] - Blame information for rev 609

Line No.	Rev	Author	Line
1	30	unneback	`/*`
2			`*`
3			`* COPYRIGHT (c) 1989-1999.`
4			`* On-Line Applications Research Corporation (OAR).`
5			`*`
6			`* The license and distribution terms for this file may be`
7			`* found in the file LICENSE in this distribution or at`
8			`* http://www.OARcorp.com/rtems/license.html.`
9			`*`
10			`* $Id: task1.c,v 1.2 2001-09-27 12:02:43 chris Exp $`
11			`*/`
12
13			`#define TEST_INIT`
14			`#include "system.h"`
15			`#include <assert.h>`
16
17			`rtems_device_major_number _STUB_major = 1;`
18
19			`rtems_id Region_id;`
20			`rtems_name Region_name;`
21			`rtems_unsigned8 Region_area[ 2048 ] CPU_STRUCTURE_ALIGNMENT;`
22
23			`#define PARTITION_SIZE 2048`
24			`#define PARTITION_ELEMENT_SIZE 128`
25			`#define PARTITION_BUFFER_POINTERS \`
26			`((PARTITION_SIZE / PARTITION_ELEMENT_SIZE) + 2)`
27
28			`rtems_id Partition_id;`
29			`rtems_name Partition_name;`
30			`rtems_unsigned8 Partition_area[ PARTITION_SIZE ] CPU_STRUCTURE_ALIGNMENT;`
31
32			`void *Buffer_address_1;`
33			`void *Buffer_address_2;`
34			`void *Buffer_address_3;`
35			`void *Buffer_address_4;`
36
37			`rtems_unsigned32 buffer_count;`
38
39			`void *Buffer_addresses[ PARTITION_BUFFER_POINTERS ];`
40
41			`rtems_task Task_1(`
42			`rtems_task_argument argument`
43			`);`
44
45			`rtems_task Task_2(`
46			`rtems_task_argument argument`
47			`);`
48
49			`rtems_task Init(`
50			`rtems_task_argument argument`
51			`)`
52			`{`
53			`rtems_status_code status;`
54
55			`Print_Warning();`
56
57			`puts( "\n\n* TIME TEST 20 *" );`
58
59			`status = rtems_task_create(`
60			`rtems_build_name( 'T', 'I', 'M', '1' ),`
61			`128,`
62			`RTEMS_MINIMUM_STACK_SIZE,`
63			`RTEMS_DEFAULT_MODES,`
64			`RTEMS_DEFAULT_ATTRIBUTES,`
65			`&Task_id[ 1 ]`
66			`);`
67			`directive_failed( status, "rtems_task_create of TASK1" );`
68
69			`status = rtems_task_start( Task_id[ 1 ], Task_1, 0 );`
70			`directive_failed( status, "rtems_task_start of TASK1" );`
71
72			`status = rtems_task_create(`
73			`rtems_build_name( 'T', 'I', 'M', '2' ),`
74			`129,`
75			`RTEMS_MINIMUM_STACK_SIZE,`
76			`RTEMS_DEFAULT_MODES,`
77			`RTEMS_DEFAULT_ATTRIBUTES,`
78			`&Task_id[ 2 ]`
79			`);`
80			`directive_failed( status, "rtems_task_create of TASK2" );`
81
82			`status = rtems_task_start( Task_id[ 2 ], Task_2, 0 );`
83			`directive_failed( status, "rtems_task_start of TASK2" );`
84
85			`status = rtems_task_delete( RTEMS_SELF );`
86			`directive_failed( status, "rtems_task_delete of RTEMS_SELF" );`
87			`}`
88
89			`rtems_task Task_1(`
90			`rtems_task_argument argument`
91			`)`
92			`{`
93			`rtems_unsigned32 index;`
94			`rtems_mode previous_mode;`
95			`rtems_task_priority previous_priority;`
96			`rtems_status_code status;`
97
98			`Partition_name = rtems_build_name( 'P', 'A', 'R', 'T' );`
99
100			`Timer_initialize();`
101			`rtems_partition_create(`
102			`Partition_name,`
103			`Partition_area,`
104			`PARTITION_SIZE,`
105			`128,`
106			`RTEMS_DEFAULT_ATTRIBUTES,`
107			`&Partition_id`
108			`);`
109			`end_time = Read_timer();`
110
111			`put_time(`
112			`"rtems_partition_create",`
113			`end_time,`
114			`1,`
115			`0,`
116			`CALLING_OVERHEAD_PARTITION_CREATE`
117			`);`
118
119			`Region_name = rtems_build_name( 'R', 'E', 'G', 'N' );`
120
121			`Timer_initialize();`
122			`rtems_region_create(`
123			`Region_name,`
124			`Region_area,`
125			`2048,`
126			`16,`
127			`RTEMS_DEFAULT_ATTRIBUTES,`
128			`&Region_id`
129			`);`
130			`end_time = Read_timer();`
131
132			`put_time(`
133			`"rtems_region_create",`
134			`end_time,`
135			`1,`
136			`0,`
137			`CALLING_OVERHEAD_REGION_CREATE`
138			`);`
139
140			`Timer_initialize();`
141			`(void) rtems_partition_get_buffer( Partition_id, &Buffer_address_1 );`
142			`end_time = Read_timer();`
143
144			`put_time(`
145			`"rtems_partition_get_buffer: available",`
146			`end_time,`
147			`1,`
148			`0,`
149			`CALLING_OVERHEAD_PARTITION_GET_BUFFER`
150			`);`
151
152			`buffer_count = 0;`
153			`while ( FOREVER ) {`
154
155			`status = rtems_partition_get_buffer(`
156			`Partition_id,`
157			`&Buffer_addresses[ buffer_count ]`
158			`);`
159
160			`if ( status == RTEMS_UNSATISFIED ) break;`
161
162			`buffer_count++;`
163
164			`assert( buffer_count < PARTITION_BUFFER_POINTERS );`
165			`}`
166
167			`Timer_initialize();`
168			`(void) rtems_partition_get_buffer( Partition_id, &Buffer_address_2 );`
169			`end_time = Read_timer();`
170
171			`put_time(`
172			`"rtems_partition_get_buffer: not available",`
173			`end_time,`
174			`1,`
175			`0,`
176			`CALLING_OVERHEAD_PARTITION_GET_BUFFER`
177			`);`
178
179			`Timer_initialize();`
180			`(void) rtems_partition_return_buffer( Partition_id, Buffer_address_1 );`
181			`end_time = Read_timer();`
182
183			`put_time(`
184			`"rtems_partition_return_buffer",`
185			`end_time,`
186			`1,`
187			`0,`
188			`CALLING_OVERHEAD_PARTITION_RETURN_BUFFER`
189			`);`
190
191			`for ( index = 0 ; index < buffer_count ; index++ ) {`
192
193			`status = rtems_partition_return_buffer(`
194			`Partition_id,`
195			`Buffer_addresses[ index ]`
196			`);`
197			`directive_failed( status, "rtems_partition_return_buffer" );`
198
199			`}`
200
201			`Timer_initialize();`
202			`(void) rtems_partition_delete( Partition_id );`
203			`end_time = Read_timer();`
204
205			`put_time(`
206			`"rtems_partition_delete",`
207			`end_time,`
208			`1,`
209			`0,`
210			`CALLING_OVERHEAD_PARTITION_DELETE`
211			`);`
212
213			`status = rtems_region_get_segment(`
214			`Region_id,`
215			`400,`
216			`RTEMS_DEFAULT_OPTIONS,`
217			`RTEMS_NO_TIMEOUT,`
218			`&Buffer_address_2`
219			`);`
220			`directive_failed( status, "region_get_segment" );`
221
222			`Timer_initialize();`
223			`(void) rtems_region_get_segment(`
224			`Region_id,`
225			`400,`
226			`RTEMS_DEFAULT_OPTIONS,`
227			`RTEMS_NO_TIMEOUT,`
228			`&Buffer_address_3`
229			`);`
230			`end_time = Read_timer();`
231
232			`put_time(`
233			`"rtems_region_get_segment: available",`
234			`end_time,`
235			`1,`
236			`0,`
237			`CALLING_OVERHEAD_REGION_GET_SEGMENT`
238			`);`
239
240			`Timer_initialize();`
241			`(void) rtems_region_get_segment(`
242			`Region_id,`
243			`1998,`
244			`RTEMS_NO_WAIT,`
245			`RTEMS_NO_TIMEOUT,`
246			`&Buffer_address_4`
247			`);`
248			`end_time = Read_timer();`
249
250			`put_time(`
251			`"rtems_region_get_segment: not available -- NO_WAIT",`
252			`end_time,`
253			`1,`
254			`0,`
255			`CALLING_OVERHEAD_REGION_GET_SEGMENT`
256			`);`
257
258			`status = rtems_region_return_segment( Region_id, Buffer_address_3 );`
259			`directive_failed( status, "rtems_region_return_segment" );`
260
261			`Timer_initialize();`
262			`(void) rtems_region_return_segment( Region_id, Buffer_address_2 );`
263			`end_time = Read_timer();`
264
265			`put_time(`
266			`"rtems_region_return_segment: no waiting tasks",`
267			`end_time,`
268			`1,`
269			`0,`
270			`CALLING_OVERHEAD_REGION_RETURN_SEGMENT`
271			`);`
272
273			`status = rtems_region_get_segment(`
274			`Region_id,`
275			`400,`
276			`RTEMS_DEFAULT_OPTIONS,`
277			`RTEMS_NO_TIMEOUT,`
278			`&Buffer_address_1`
279			`);`
280			`directive_failed( status, "rtems_region_get_segment" );`
281
282			`Timer_initialize();`
283			`(void) rtems_region_get_segment(`
284			`Region_id,`
285			`1998,`
286			`RTEMS_DEFAULT_OPTIONS,`
287			`RTEMS_NO_TIMEOUT,`
288			`&Buffer_address_2`
289			`);`
290
291			`/* execute Task_2 */`
292
293			`end_time = Read_timer();`
294
295			`put_time(`
296			`"rtems_region_return_segment: task readied -- preempts caller",`
297			`end_time,`
298			`1,`
299			`0,`
300			`CALLING_OVERHEAD_REGION_RETURN_SEGMENT`
301			`);`
302
303			`status = rtems_region_return_segment( Region_id, Buffer_address_2 );`
304			`directive_failed( status, "rtems_region_return_segment" );`
305
306			`status = rtems_task_mode(`
307			`RTEMS_NO_PREEMPT,`
308			`RTEMS_PREEMPT_MASK,`
309			`&previous_mode`
310			`);`
311			`directive_failed( status, "rtems_task_mode" );`
312
313			`status = rtems_task_set_priority( RTEMS_SELF, 254, &previous_priority );`
314			`directive_failed( status, "rtems_task_set_priority" );`
315
316			`status = rtems_region_get_segment(`
317			`Region_id,`
318			`400,`
319			`RTEMS_DEFAULT_OPTIONS,`
320			`RTEMS_NO_TIMEOUT,`
321			`&Buffer_address_1`
322			`);`
323			`directive_failed( status, "rtems_region_return_segment" );`
324
325			`status = rtems_region_get_segment(`
326			`Region_id,`
327			`1998,`
328			`RTEMS_DEFAULT_OPTIONS,`
329			`RTEMS_NO_TIMEOUT,`
330			`&Buffer_address_2`
331			`);`
332			`directive_failed( status, "rtems_region_get_segment" );`
333
334			`/* execute Task_2 */`
335
336			`status = rtems_region_return_segment( Region_id, Buffer_address_2 );`
337			`directive_failed( status, "rtems_region_return_segment" );`
338
339			`Timer_initialize();`
340			`(void) rtems_region_delete( Region_id );`
341			`end_time = Read_timer();`
342
343			`put_time(`
344			`"rtems_region_delete",`
345			`end_time,`
346			`1,`
347			`0,`
348			`CALLING_OVERHEAD_REGION_DELETE`
349			`);`
350
351			`Timer_initialize();`
352			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
353			`(void) Empty_function();`
354			`overhead = Read_timer();`
355
356			`Timer_initialize();`
357			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
358			`(void) rtems_io_initialize( _STUB_major, 0, NULL );`
359			`end_time = Read_timer();`
360
361			`put_time(`
362			`"rtems_io_initialize",`
363			`end_time,`
364			`OPERATION_COUNT,`
365			`overhead,`
366			`CALLING_OVERHEAD_IO_INITIALIZE`
367			`);`
368
369			`Timer_initialize();`
370			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
371			`(void) rtems_io_open( _STUB_major, 0, NULL );`
372			`end_time = Read_timer();`
373
374			`put_time(`
375			`"rtems_io_open",`
376			`end_time,`
377			`OPERATION_COUNT,`
378			`overhead,`
379			`CALLING_OVERHEAD_IO_OPEN`
380			`);`
381
382			`Timer_initialize();`
383			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
384			`(void) rtems_io_close( _STUB_major, 0, NULL );`
385			`end_time = Read_timer();`
386
387			`put_time(`
388			`"rtems_io_close",`
389			`end_time,`
390			`OPERATION_COUNT,`
391			`overhead,`
392			`CALLING_OVERHEAD_IO_CLOSE`
393			`);`
394
395			`Timer_initialize();`
396			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
397			`(void) rtems_io_read( _STUB_major, 0, NULL );`
398			`end_time = Read_timer();`
399
400			`put_time(`
401			`"rtems_io_read",`
402			`end_time,`
403			`OPERATION_COUNT,`
404			`overhead,`
405			`CALLING_OVERHEAD_IO_READ`
406			`);`
407
408			`Timer_initialize();`
409			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
410			`(void) rtems_io_write( _STUB_major, 0, NULL );`
411			`end_time = Read_timer();`
412
413			`put_time(`
414			`"rtems_io_write",`
415			`end_time,`
416			`OPERATION_COUNT,`
417			`overhead,`
418			`CALLING_OVERHEAD_IO_WRITE`
419			`);`
420
421			`Timer_initialize();`
422			`for ( index=1 ; index <= OPERATION_COUNT ; index++ )`
423			`(void) rtems_io_control( _STUB_major, 0, NULL );`
424			`end_time = Read_timer();`
425
426			`put_time(`
427			`"rtems_io_control",`
428			`end_time,`
429			`OPERATION_COUNT,`
430			`overhead,`
431			`CALLING_OVERHEAD_IO_CONTROL`
432			`);`
433
434			`puts( "* END OF TEST 20 *" );`
435			`exit( 0 );`
436			`}`
437
438			`rtems_task Task_2(`
439			`rtems_task_argument argument`
440			`)`
441			`{`
442			`rtems_status_code status;`
443
444			`end_time = Read_timer();`
445
446			`put_time(`
447			`"rtems_region_get_segment: not available -- caller blocks",`
448			`end_time,`
449			`1,`
450			`0,`
451			`CALLING_OVERHEAD_REGION_GET_SEGMENT`
452			`);`
453
454			`Timer_initialize();`
455			`(void) rtems_region_return_segment( Region_id, Buffer_address_1 );`
456
457			`/* preempt back to Task_1 */`
458
459			`Timer_initialize();`
460			`(void) rtems_region_return_segment( Region_id, Buffer_address_1 );`
461			`end_time = Read_timer();`
462
463			`put_time(`
464			`"rtems_region_return_segment: task readied -- returns to caller",`
465			`end_time,`
466			`1,`
467			`0,`
468			`CALLING_OVERHEAD_REGION_RETURN_SEGMENT`
469			`);`
470
471			`status = rtems_task_delete( RTEMS_SELF );`
472			`directive_failed( status, "rtems_task_delete of RTEMS_SELF" );`
473			`}`