463cd9d2477224640870f4630c8e9d195e956b4c
[processor-sdk/performance-audio-sr.git] / processor_audio_sdk_1_00_00_00 / pasdk / common / paf_alg_malloc.c
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)
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     }
146     
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                             0);
211                     TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes from space %d", __LINE__, memTab[i].size, memTab[i].space));
212                     //if(!(memTab[i].base=(void *)MEM_alloc(
213                     //    PAF_ALG_memSpace(&pafConfig,memTab[i].space),
214                     //    memTab[i].size,memTab[i].alignment)))
215                     if (!(memTab[i].base = (void *)Memory_alloc(
216                         (IHeap_Handle)PAF_ALG_memSpaceToHeap(&pafConfig, memTab[i].space),
217                         memTab[i].size,
218                         memTab[i].alignment, 
219                         &eb)))
220                     {
221                         TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.",__LINE__, memTab[i].size));
222                         SW_BREAKPOINT;
223                         return PAF_ALGERR_PERSIST;
224                     }
225                     TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x",
226                                    memTab[i].size, memTab[i].base, PAF_ALG_memSpace(&pafConfig,memTab[i].space)));
227                 }
228             }
229             else
230             {
231                 memTab[i].base=NULL;
232                 TRACE_TERSE((&TR_MOD, "PAF_ALG_allocMemory_.%d: alloc %d bytes failed.", __LINE__, memTab[i].size));
233                 SW_BREAKPOINT;
234             }
235         }
236     }
237     return 0;
240 /*
241  * The PAF_ALG_mallocMemory function allocates the memory requested by the 
242  * memTab's.
243  */
245 Int
246 PAF_ALG_mallocMemory_ (
247     IALG_MemRec common[], 
248     PAF_IALG_Config *p)
250     Int i;
251     Error_Block eb;
252     
253     // Initialize error block
254     Error_init(&eb);
255     
256     for(i=PAF_IALG_COMMON_MEM0;i<=PAF_IALG_COMMON_MEMN;++i)
257     {
258         if(0 == common[i].size)
259             continue;
261         if(p->clr)
262         {
263             TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: calloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
264             //common[i].base = (void *)MEM_calloc( PAF_ALG_memSpace(p,common[i].space), common[i].size, common[i].alignment);
265             common[i].base = (void *)Memory_calloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p,common[i].space), common[i].size, common[i].alignment, &eb);
266             TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
267         }
268         else
269         {
270             TRACE_GEN((&TR_MOD, "PAF_ALG_mallocMemory_.%d: alloc %d bytes from space %d", __LINE__, common[i].size, common[i].space));
271             //common[i].base = (void *)MEM_alloc(PAF_ALG_memSpace(p, common[i].space),common[i].size, common[i].alignment);
272             common[i].base = (void *)Memory_alloc((IHeap_Handle)PAF_ALG_memSpaceToHeap(p, common[i].space), common[i].size, common[i].alignment, &eb);
273             TRACE_GEN((&TR_MOD, "PAF_ALG_allocMemory_ (cont'd) %d at 0x%x", common[i].size, common[i].base));
274         }
276         if(!(common[i].base))
277         {
278             TRACE_TERSE((&TR_MOD, "PAF_ALG_mallocMemory_.%d: (c)alloc %d bytes failed", __LINE__, common[i].size));
279             SW_BREAKPOINT;
280             return PAF_ALGERR_COMMON;
281         }
282     }
284     return 0;
287 /*
288  * The PAF_ALG_freeMemory is derived from _ALG_freeMemory function defined 
289  * in the TI Standard XDAIS file alg_malloc.c version "XDAS 2.2.1 12-07-01"
290  * It is extended to check for the Performance Audio specific "Common"
291  * memory and scratch memory.
292  */
294 Void 
295 PAF_ALG_freeMemory(
296     IALG_MemRec memTab[], 
297     Int n)
300 #ifdef _TMS320C6X
301 //#warn Cannot free memory here because segids are not known
302 #endif
304     // Cannot free memory here bacause there is no way to determine
305     // the segid needed by MEM_free.
306     // Not an issuue as of now, in PA, because, if alg creation fails
307     // system does not do any thing further.
308     // 
309 #if 0
310     Int i;
311     Int segid;
313     for(i=0;i<n;i++){
314         if(memTab[i].base != NULL && !(memTab[i].attrs == PAF_IALG_COMMON_MEM0 ||
315            memTab[i].attrs >= PAF_IALG_COMMON_MEM1 && memTab[i].attrs <= PAF_IALG_COMMON_MEMN))
316         {
317 #warn MEM_free might be 
318             segid = (memTab[i].space == IALG_SARAM)?IRAM:SDRAM;
319             MEM_free(segid,memTab[i].base,memTab[i].size);
320         }
321     }
322 #endif
325 /* 
326  * The PAF_ALG_init function initializes the memTab's to default values.
327  */
329 Void 
330 PAF_ALG_init_ (
331     IALG_MemRec memTab[], 
332     Int n, 
333     const IALG_MemSpace memSpace[])
335     Int i;
337     for (i=0; i<n; i++) {
338         memTab[i].size = 0;
339         memTab[i].alignment = 0;
340         memTab[i].base = NULL;
341         memTab[i].space = memSpace ? memSpace[i] : PAF_IALG_NONE;
342         // TRACE_GEN((&TR_MOD, "PAF_ALG_init_[%d]:space %d", i, memTab[i].space));
343     }
346 /*
347  *  PAF_ALG_activate is derived from standard XDAIS ALG_activate function defined in the
348  *  file alg_malloc.c version "XDAS 2.2.1 12-07-01".
349  */
351 #ifdef _TMS320C6X
352 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
353 #pragma CODE_SECTION(PAF_ALG_activate,".text:_PAF_ALG_activate")
354 #endif
356 Void
357 PAF_ALG_activate (
358     ALG_Handle alg)
360 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
361     asm (" .clink");
362 #endif    
364     if (alg->fxns->algActivate != NULL) {
365         alg->fxns->algActivate (alg);
366     }
369 /*
370  *  PAF_ALG_deactivate is derived from standard XDAIS ALG_deactivate function defined in the
371  *  file alg_malloc.c version "XDAS 2.2.1 12-07-01".
372  */
374 #ifdef _TMS320C6X
375 /* DO NOT REMOVE THIS CODE_SECTION. --Kurt */
376 #pragma CODE_SECTION(PAF_ALG_deactivate,".text:_PAF_ALG_deactivate")
377 #endif
379 Void 
380 PAF_ALG_deactivate (
381     ALG_Handle alg)
383 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
384     asm (" .clink");
385 #endif
387     if (alg->fxns->algDeactivate != NULL) {
388         alg->fxns->algDeactivate(alg);
389     }   
392 /* 
393  * The PAF_ALG_memSpaceToHeapId function is derived from ALGRF_memSpace function 
394  * defined in the TI released algrf.h file ver "ALGRF 0.02.06 11-21-01".
395  */
397 Int
398 PAF_ALG_memSpaceToHeapId_ (
399     const PAF_IALG_Config *p, 
400     IALG_MemSpace space)
402     switch(space)
403     {
404         case IALG_SARAM:    /* IALG_SARAM0 = IALG_SARAM :  Normally used for IRAM.  */
405             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
406             return p->iHeapId;
408         case IALG_EXTERNAL: // normally external SDRAM
409             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
410             return p->eHeapId;
412         case IALG_SARAM1:
413             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
414             return p->lHeapId;
416         case IALG_SARAM2:
417             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_SARAM2 (0x%x) 0x%x", __LINE__, space, p->lHeapIdShm));
418             return p->lHeapIdShm;
420         case IALG_DARAM0:   // Can't use this because it is zero and overridden
421             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
422             return p->iHeapId;
424         case IALG_DARAM1:   // not normally used.
425             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
426             return p->iHeapId;
428         case IALG_DARAM2:   // not normally used.
429             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
430             return p->iHeapId;    // not normally used.
432         case IALG_ESDATA:   // not normally used.
433             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapId));
434             return p->eHeapId;
436         default:
437             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeapId_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
438             return p->eHeapId;
439     }
440  
443 HeapMem_Handle
444 PAF_ALG_memSpaceToHeap_ (
445     const PAF_IALG_Config *p, 
446     IALG_MemSpace space)
448     switch(space)
449     {
450         case IALG_SARAM:    /* IALG_SARAM0 = IALG_SARAM :  Normally used for IRAM.  */
451             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM (0x%x) 0x%x", __LINE__, space, p->iHeapId));
452             return p->hIHeap;
454         case IALG_EXTERNAL: // normally external SDRAM
455             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_EXTERNAL (0x%x) 0x%x", __LINE__, space, p->eHeapId));
456             return p->hEHeap;
458         case IALG_SARAM1:   // Used by Dolby Digital
459             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM1 (0x%x) 0x%x", __LINE__, space, p->lHeapId));
460             return p->hLHeap;
462         case IALG_SARAM2:
463             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_SARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
464             return p->hLHeapShm;
466         case IALG_DARAM0:   // Can't use this because it is zero and overridden
467             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM0 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
468             return p->hIHeap;
470         case IALG_DARAM1:   // not normally used.
471             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM1 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
472             return p->hIHeap;
474         case IALG_DARAM2:   // not normally used.
475             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_DARAM2 (0x%x) 0x%x", __LINE__, space, p->iHeapId));
476             return p->hIHeap;    // not normally used.
478         case IALG_ESDATA:   // not normally used.
479             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: IALG_ESDATA (0x%x) 0x%x", __LINE__, space, p->eHeapId));
480             return p->hEHeap;
482         default:
483             TRACE_GEN((&TR_MOD, "PAF_ALG_memSpaceToHeap_.%d: default (0x%x) 0x%x", __LINE__, space, p->eHeapId));
484             return p->hEHeap;
485     } 
488 /* 
489  * The PAF_ALG_setup function is derived from ALGRF_setup function defined in
490  * the TI released algrf_setup.c file ver "ALGRF 0.02.06 11-21-01" .
491  */
492     
493 #ifdef _TMS320C6X
494 #pragma CODE_SECTION(PAF_ALG_setup_,".text:_PAF_ALG_setup_")
495 #endif
496 Void
497 PAF_ALG_setup_ (
498     PAF_IALG_Config *p, 
499     Int iHeapId, 
500     HeapMem_Handle hIHeap,
501     Int lHeapId,
502     HeapMem_Handle hLHeap,
503     Int eHeapId,
504     HeapMem_Handle hEHeap,
505     Int lHeapIdShm,
506     HeapMem_Handle hLHeapShm,
507     Int clr
509
510 #if defined(_TMS320C6X) && !defined(__TI_EABI__)
511     asm (" .clink");
512 #endif    
513     
514     /* initialize heap Ids */
515     p->iHeapId      = iHeapId; 
516     p->lHeapId      = lHeapId;
517     p->eHeapId      = eHeapId;
518     p->lHeapIdShm   = lHeapIdShm;
519     
520     /* initialize heap handles */
521     p->hIHeap       = hIHeap;
522     p->hLHeap       = hLHeap;
523     p->hEHeap       = hEHeap;
524     p->hLHeapShm    = hLHeapShm;
525     
526     /* initialize clear flag */
527     p->clr=clr;
528     
529     // TRACE_GEN((&TR_MOD, "PAF_ALG_memSpace_.%d: IPAF_ALG_setup_", __LINE__));