2 /*
3 Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the
16 * distribution.
17 *
18 * Neither the name of Texas Instruments Incorporated nor the names of
19 * its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 */
36 //
37 // Algorithm Memory Allocation
38 //
40 /*
41 * File Inclusions
42 */
44 #include <xdc/std.h>
45 #include <xdc/cfg/global.h>
47 //#include <mem.h>
48 #include <xdc/runtime/Error.h>
49 #include <xdc/runtime/Memory.h>
50 #include <xdc/runtime/IHeap.h>
51 #include <ti/sysbios/heaps/HeapMem.h>
53 //#include <stdlib.h>
54 //#include <string.h>
56 #include "alg.h"
58 //#include "pafhjt.h"
59 #include "paf_alg.h"
60 #include "paf_alg_priv.h"
62 #include "common.h"
63 #include "paf_heapMgr.h"
65 //extern int IRAM;
66 //extern int SDRAM;
67 //extern int L3RAM;
70 // -----------------------------------------------------------------------------
71 // Debugging Trace Control, local to this file.
72 //
74 #define PAF_DEVICE_VERSION (PAF_DEVICE & 0xffff)
75 #if PAF_DEVICE_VERSION == 0xE000
76 #define _DEBUG // This is to enable log_printfs
77 #endif /* PAF_DEVICE_VERSION */
79 #include <logp.h>
81 // allows you to set a different trace module in pa.cfg
82 #define TR_MOD trace
84 // Allow a developer to selectively enable tracing.
85 // For release, set mask to 1 to make it easier to catch any errors.
86 #define CURRENT_TRACE_MASK 0 // terse only
88 #define TRACE_MASK_TERSE 1 // only flag errors
89 #define TRACE_MASK_GENERAL 2 // log a half dozen lines per loop
90 #define TRACE_MASK_VERBOSE 4 // trace full operation
92 #if (CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
93 #define TRACE_TERSE(a) LOG_printf a
94 #else
95 #define TRACE_TERSE(a)
96 #endif
98 #if (CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
99 #define TRACE_GEN(a) LOG_printf a
100 #else
101 #define TRACE_GEN(a)
102 #endif
104 #if (CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
105 #define TRACE_VERBOSE(a) LOG_printf a
106 #else
107 #define TRACE_VERBOSE(a)
108 #endif
110 // Note: memory spaces are defined in ialg.h from the xdais package.
111 // 17 is external. 2 and 5 are internal.
113 /*
114 * The PAF_ALG_allocMemory is derived from _ALG_allocMemory function defined
115 * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
116 * It is extended to check for the Performance Audio specific "Common"
117 * memory. This function assumes that memory is already
118 * allocated for the common memory and shared scratch memory.
119 */
121 Int
122 PAF_ALG_allocMemory_ (
123 IALG_MemRec memTab[],
124 Int n,
125 const IALG_MemRec common[],
126 PAF_IALG_Config *p)
127 {
128 char * commonBase[PAF_IALG_COMMON_MEMN+1];
129 Int commonCount[PAF_IALG_COMMON_MEMN+1];
130 Int i;
131 Error_Block eb;
133 // Initialize error block
134 Error_init(&eb);
136 if(common) {
137 #ifdef _TMS320C6X
138 //#warn This pragma saves ~125 bytes! --Kurt
139 #pragma UNROLL(1)
140 #endif
141 for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i) {
142 commonBase[i]=common[i].base;
143 commonCount[i]=0;
144 }
145 }
147 for(i=0;i<n;++i) {
148 if( common &&
149 (memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
150 (memTab[i].attrs >= PAF_IALG_COMMON_MEM1 &&
151 memTab[i].attrs <= PAF_IALG_COMMON_MEMN))) {
152 memTab[i].base = commonBase[memTab[i].attrs] +
153 (commonCount[memTab[i].attrs] ? memTab[i].alignment : 0);
154 memTab[i].base = (void *)((unsigned int )memTab[i].base &
155 (~(memTab[i].alignment ? memTab[i].alignment - 1 : 0)));
156 commonBase[memTab[i].attrs] = (char *)memTab[i].base + memTab[i].size;
157 commonCount[memTab[i].attrs]++;
158 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: memTab alloc %d bytes at 0x%x.", __LINE__, memTab[i].size, memTab[i].base));
159 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) memTab %d. i: %d", memTab[i].attrs, i));
160 }
161 else {
162 if(memTab[i].size){
163 if(p) {
164 if(p->clr){
165 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: calloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
166 //if(!(memTab[i].base = (void *)MEM_calloc(
167 // PAF_ALG_memSpace(p,memTab[i].space),
168 // memTab[i].size,memTab[i].alignment)))
169 if (!(memTab[i].base = (void *)Memory_calloc(
170 (IHeap_Handle)PAF_ALG_memSpaceToHeap(p,memTab[i].space),
171 memTab[i].size,
172 memTab[i].alignment,
173 &eb)))
174 {
175 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: calloc %d bytes failed.", __LINE__, memTab[i].size));
176 SW_BREAKPOINT;
177 return PAF_ALGERR_PERSIST;
178 }
179 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x, %d",
180 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(p,memTab[i].space)));
181 }
182 else{
183 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
184 //if(!(memTab[i].base = (void *)MEM_alloc(
185 // PAF_ALG_memSpace(p,memTab[i].space),
186 // memTab[i].size,memTab[i].alignment)))
187 if (!(memTab[i].base = (void *)Memory_alloc(
188 (IHeap_Handle)PAF_ALG_memSpaceToHeap(p, memTab[i].space),
189 memTab[i].size,
190 memTab[i].alignment,
191 &eb)))
192 {
193 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
194 SW_BREAKPOINT;
195 return PAF_ALGERR_PERSIST;
196 }
197 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x, %d",
198 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(p,memTab[i].space)));
199 }
200 }
201 else {
202 PAF_IALG_Config pafConfig;
203 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: Setup memory regions.", __LINE__));
204 //PAF_ALG_setup(&pafConfig,IRAM,SDRAM,IRAM,0); // option: use L3RAM
205 PAF_ALG_setup(&pafConfig,
206 gPafHeapIdInt, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt),
207 gPafHeapIdInt1, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt1),
208 gPafHeapIdExt, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExt),
209 gPafHeapIdInt1Shm, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdInt1Shm),
210 gPafHeapIdExtShm, (HeapMem_Handle)pafHeapMgr_readHeapHandle(gPafHeapIdExtShm),
211 0);
212 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
213 //if(!(memTab[i].base=(void *)MEM_alloc(
214 // PAF_ALG_memSpace(&pafConfig,memTab[i].space),
215 // memTab[i].size,memTab[i].alignment)))
216 if (!(memTab[i].base = (void *)Memory_alloc(
217 (IHeap_Handle)PAF_ALG_memSpaceToHeap(&pafConfig, memTab[i].space),
218 memTab[i].size,
219 memTab[i].alignment,
220 &eb)))
221 {
222 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.",__LINE__, memTab[i].size));
223 SW_BREAKPOINT;
224 return PAF_ALGERR_PERSIST;
225 }
226 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x",
227 memTab[i].size, memTab[i].base, PAF_ALG_memSpace(&pafConfig,memTab[i].space)));
228 }
229 }
230 else
231 {
232 memTab[i].base=NULL;
233 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
234 SW_BREAKPOINT;
235 }
236 }
237 }
238 return 0;
239 }
241 /*
242 * The PAF_ALG_mallocMemory function allocates the memory requested by the
243 * memTab's.
244 */
246 Int
247 PAF_ALG_mallocMemory_ (
248 IALG_MemRec common[],
249 PAF_IALG_Config *p)
250 {
251 Int i;
252 Error_Block eb;
254 // Initialize error block
255 Error_init(&eb);
257 for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i)
258 {
259 if(0 == common[i].size)
260 continue;
262 if(p->clr)
263 {
264 TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: calloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
265 //common[i].base = (void *)MEM_calloc( PAF_ALG_memSpace(p,common[i].space), common[i].size, common[i].alignment);
266 common[i].base = (void *)Memory_calloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p,common[i].space), common[i].size, common[i].alignment, &eb);
267 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
268 }
269 else
270 {
271 TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: alloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
272 //common[i].base = (void *)MEM_alloc(PAF_ALG_memSpace(p, common[i].space),common[i].size, common[i].alignment);
273 common[i].base = (void *)Memory_alloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p, common[i].space), common[i].size, common[i].alignment, &eb);
274 TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
275 }
277 if(!(common[i].base))
278 {
279 TRACE_TERSE((&TR_MOD, "PAF_ALG_mallocMemory_.%d: (c)alloc %d bytes failed", __LINE__, common[i].size));
280 SW_BREAKPOINT;
281 return PAF_ALGERR_COMMON;
282 }
283 }
285 return 0;
286 }
288 /*
289 * The PAF_ALG_freeMemory is derived from _ALG_freeMemory function defined
290 * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
291 * It is extended to check for the Performance Audio specific "Common"
292 * memory and scratch memory.
293 */
295 Void
296 PAF_ALG_freeMemory(
297 IALG_MemRec memTab[],
298 Int n)
299 {
301 #ifdef _TMS320C6X
302 //#warn Cannot free memory here because segids are not known
303 #endif
305 // Cannot free memory here bacause there is no way to determine
306 // the segid needed by MEM_free.
307 // Not an issuue as of now, in PA, because, if alg creation fails
308 // system does not do any thing further.
309 //
310 #if 0
311 Int i;
312 Int segid;
314 for(i=0;i<n;i++){
315 if(memTab[i].base != NULL && !(memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
316 memTab[i].attrs >= PAF_IALG_COMMON_MEM1 && memTab[i].attrs <= PAF_IALG_COMMON_MEMN))
317 {
318 #warn MEM_free might be
319 segid = (memTab[i].space == IALG_SARAM)?IRAM:SDRAM;
320 MEM_free(segid,memTab[i].base,memTab[i].size);
321 }
322 }
323 #endif
324 }
326 /*
327 * The PAF_ALG_init function initializes the memTab's to default values.
328 */
330 Void
331 PAF_ALG_init_ (
332 IALG_MemRec memTab[],
333 Int n,
334 const IALG_MemSpace memSpace[])
335 {
336 Int i;
338 for (i=0; i<n; i++) {
339 memTab[i].size = 0;
340 memTab[i].alignment = 0;
341 memTab[i].base = NULL;
342 memTab[i].space = memSpace ? memSpace[i] : PAF_IALG_NONE;
343 // TRACE_GEN((&TR_MOD, "PAF_ALG_init_[%d]:space %d", i, memTab[i].space));
344 }
345 }
347 /*
348 * PAF_ALG_activate is derived from standard XDAIS ALG_activate function defined in the
349 * file alg_malloc.c version "XDAS 2.2.1 12-07-01".
350 */
352 #ifdef _TMS320C6X
353 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
354 #pragma CODE_SECTION(PAF_ALG_activate,".text:_PAF_ALG_activate")
355 #endif
357 Void
358 PAF_ALG_activate (
359 ALG_Handle alg)
360 {
361 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
362 asm (" .clink");
363 #endif
365 if (alg->fxns->algActivate != NULL) {
366 alg->fxns->algActivate (alg);
367 }
368 }
370 /*
371 * PAF_ALG_deactivate is derived from standard XDAIS ALG_deactivate function defined in the
372 * file alg_malloc.c version "XDAS 2.2.1 12-07-01".
373 */
375 #ifdef _TMS320C6X
376 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
377 #pragma CODE_SECTION(PAF_ALG_deactivate,".text:_PAF_ALG_deactivate")
378 #endif
380 Void
381 PAF_ALG_deactivate (
382 ALG_Handle alg)
383 {
384 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
385 asm (" .clink");
386 #endif
388 if (alg->fxns->algDeactivate != NULL) {
389 alg->fxns->algDeactivate(alg);
390 }
391 }
393 /*
394 * The PAF_ALG_memSpaceToHeapId function is derived from ALGRF_memSpace function
395 * defined in the TI released algrf.h file ver "ALGRF 0.02.06 11-21-01".
396 */
398 Int
399 PAF_ALG_memSpaceToHeapId_ (
400 const PAF_IALG_Config *p,
401 IALG_MemSpace space)
402 {
403 switch(space)
404 {
405 case IALG_SARAM: /* IALG_SARAM0 = IALG_SARAM : Normally used for IRAM */ // FL: K2G: used for L2 on DSP
406 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
407 return p->iHeapId;
409 case IALG_EXTERNAL: // normally external SDRAM // FL: K2G: used for DDR local memory
410 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
411 return p->eHeapId;
413 case IALG_SARAM1: // FL: K2G: used for MSMC local memory
414 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
415 return p->lHeapId;
417 case IALG_SARAM2: // FL: K2G: used for MSMC shared memory
418 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM2 (IALG_SARAM_SHM) (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
419 return p->lHeapIdShm;
421 case IALG_DARAM0: // Can't use this because it is zero and overridden
422 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
423 return p->iHeapId;
425 case IALG_DARAM1: // not normally used.
426 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
427 return p->iHeapId;
429 case IALG_DARAM2: // not normally used.
430 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
431 return p->iHeapId; // not normally used.
433 case IALG_ESDATA: // FL: K2G: used for DDR shared memory
434 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_ESDATA (IALG_EXTERNAL_SHM) (0x%x) 0x%x", __LINE__, space, p->eHeapIdShm));
435 return p->eHeapIdShm;
437 default:
438 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
439 return p->eHeapId;
440 }
442 }
444 HeapMem_Handle
445 PAF_ALG_memSpaceToHeap_ (
446 const PAF_IALG_Config *p,
447 IALG_MemSpace space)
448 {
449 switch(space)
450 {
451 case IALG_SARAM: /* IALG_SARAM0 = IALG_SARAM : Normally used for IRAM. */ // FL: K2G: used for L2 on DSP
452 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
453 return p->hIHeap;
455 case IALG_EXTERNAL: // normally external SDRAM // FL: K2G: used for DDR local memory
456 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
457 return p->hEHeap;
459 case IALG_SARAM1: // FL: K2G: used for MSMC local memory
460 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
461 return p->hLHeap;
463 case IALG_SARAM2:
464 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM2 (IALG_SARAM_SHM) (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
465 return p->hLHeapShm;
467 case IALG_DARAM0: // Can't use this because it is zero and overridden
468 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
469 return p->hIHeap;
471 case IALG_DARAM1: // not normally used.
472 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
473 return p->hIHeap;
475 case IALG_DARAM2: // not normally used.
476 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
477 return p->hIHeap; // not normally used.
479 case IALG_ESDATA: // FL: K2G: used for DDR shared memory
480 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapIdShm));
481 return p->hEHeapShm;
483 default:
484 TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
485 return p->hEHeap;
486 }
487 }
489 /*
490 * The PAF_ALG_setup function is derived from ALGRF_setup function defined in
491 * the TI released algrf_setup.c file ver "ALGRF 0.02.06 11-21-01" .
492 */
494 #ifdef _TMS320C6X
495 #pragma CODE_SECTION(PAF_ALG_setup_,".text:_PAF_ALG_setup_")
496 #endif
497 Void
498 PAF_ALG_setup_ (
499 PAF_IALG_Config *p,
500 Int iHeapId,
501 HeapMem_Handle hIHeap,
502 Int lHeapId,
503 HeapMem_Handle hLHeap,
504 Int eHeapId,
505 HeapMem_Handle hEHeap,
506 Int lHeapIdShm,
507 HeapMem_Handle hLHeapShm,
508 Int eHeapIdShm,
509 HeapMem_Handle hEHeapShm,
510 Int clr
511 )
512 {
513 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
514 asm (" .clink");
515 #endif
517 /* initialize heap Ids */
518 p->iHeapId = iHeapId;
519 p->lHeapId = lHeapId;
520 p->eHeapId = eHeapId;
521 p->lHeapIdShm = lHeapIdShm;
522 p->eHeapIdShm = eHeapIdShm;
524 /* initialize heap handles */
525 p->hIHeap = hIHeap;
526 p->hLHeap = hLHeap;
527 p->hEHeap = hEHeap;
528 p->hLHeapShm = hLHeapShm;
529 p->hEHeapShm = hEHeapShm;
531 /* initialize clear flag */
532 p->clr=clr;
534 // TRACE_GEN((&TR_MOD, "PAF_ALG_memSpace_.%d: IPAF_ALG_setup_", __LINE__));
535 }