Menu
▾
▴
[Valgrind-developers] valgrind: r8565 - branches/YARD/callgrind
|
From: <sv...@va...> - 2008-09-06 18:45:41
|
Author: sewardj
Date: 2008-09-06 19:45:50 +0100 (Sat, 06 Sep 2008)
New Revision: 8565
Log:
Add cost-center annotations to all allocation points in Callgrind.
Modified:
branches/YARD/callgrind/bb.c
branches/YARD/callgrind/bbcc.c
branches/YARD/callgrind/callstack.c
branches/YARD/callgrind/clo.c
branches/YARD/callgrind/command.c
branches/YARD/callgrind/context.c
branches/YARD/callgrind/costs.c
branches/YARD/callgrind/debug.c
branches/YARD/callgrind/dump.c
branches/YARD/callgrind/events.c
branches/YARD/callgrind/fn.c
branches/YARD/callgrind/global.h
branches/YARD/callgrind/jumps.c
branches/YARD/callgrind/sim.c
branches/YARD/callgrind/threads.c
Modified: branches/YARD/callgrind/bb.c
===================================================================
--- branches/YARD/callgrind/bb.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/bb.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -41,7 +41,8 @@
bbs.size = 8437;
bbs.entries = 0;
- bbs.table = (BB**) CLG_MALLOC(bbs.size * sizeof(BB*));
+ bbs.table = (BB**) CLG_MALLOC("cl.bb.ibh.1",
+ bbs.size * sizeof(BB*));
for (i = 0; i < bbs.size; i++) bbs.table[i] = NULL;
}
@@ -70,7 +71,8 @@
UInt new_idx;
new_size = 2* bbs.size +3;
- new_table = (BB**) CLG_MALLOC(new_size * sizeof(BB*));
+ new_table = (BB**) CLG_MALLOC("cl.bb.rbt.1",
+ new_size * sizeof(BB*));
if (!new_table) return;
@@ -129,7 +131,7 @@
size = sizeof(BB) + instr_count * sizeof(InstrInfo)
+ (cjmp_count+1) * sizeof(CJmpInfo);
- new = (BB*) CLG_MALLOC(size);
+ new = (BB*) CLG_MALLOC("cl.bb.nb.1", size);
VG_(memset)(new, 0, size);
new->obj = obj;
Modified: branches/YARD/callgrind/bbcc.c
===================================================================
--- branches/YARD/callgrind/bbcc.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/bbcc.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -48,7 +48,8 @@
bbccs->size = N_BBCC_INITIAL_ENTRIES;
bbccs->entries = 0;
- bbccs->table = (BBCC**) CLG_MALLOC(bbccs->size * sizeof(BBCC*));
+ bbccs->table = (BBCC**) CLG_MALLOC("cl.bbcc.ibh.1",
+ bbccs->size * sizeof(BBCC*));
for (i = 0; i < bbccs->size; i++) bbccs->table[i] = NULL;
}
@@ -197,7 +198,8 @@
BBCC *curr_BBCC, *next_BBCC;
new_size = 2*current_bbccs.size+3;
- new_table = (BBCC**) CLG_MALLOC(new_size * sizeof(BBCC*));
+ new_table = (BBCC**) CLG_MALLOC("cl.bbcc.rbh.1",
+ new_size * sizeof(BBCC*));
if (!new_table) return;
@@ -246,7 +248,7 @@
BBCC** bbccs;
int i;
- bbccs = (BBCC**) CLG_MALLOC(sizeof(BBCC*) * size);
+ bbccs = (BBCC**) CLG_MALLOC("cl.bbcc.nr.1", sizeof(BBCC*) * size);
for(i=0;i<size;i++)
bbccs[i] = 0;
@@ -271,7 +273,8 @@
/* We need cjmp_count+1 JmpData structs:
* the last is for the unconditional jump/call/ret at end of BB
*/
- new = (BBCC*)CLG_MALLOC(sizeof(BBCC) +
+ new = (BBCC*)CLG_MALLOC("cl.bbcc.nb.1",
+ sizeof(BBCC) +
(bb->cjmp_count+1) * sizeof(JmpData));
new->bb = bb;
new->tid = CLG_(current_tid);
Modified: branches/YARD/callgrind/callstack.c
===================================================================
--- branches/YARD/callgrind/callstack.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/callstack.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -52,7 +52,8 @@
CLG_ASSERT(s != 0);
s->size = N_CALL_STACK_INITIAL_ENTRIES;
- s->entry = (call_entry*) CLG_MALLOC(s->size * sizeof(call_entry));
+ s->entry = (call_entry*) CLG_MALLOC("cl.callstack.ics.1",
+ s->size * sizeof(call_entry));
s->sp = 0;
s->entry[0].cxt = 0; /* for assertion in push_cxt() */
@@ -96,7 +97,8 @@
cs->size *= 2;
while (i > cs->size) cs->size *= 2;
- cs->entry = (call_entry*) VG_(realloc)(cs->entry,
+ cs->entry = (call_entry*) VG_(realloc)("cl.callstack.ess.1",
+ cs->entry,
cs->size * sizeof(call_entry));
for(i=oldsize; i<cs->size; i++)
Modified: branches/YARD/callgrind/clo.c
===================================================================
--- branches/YARD/callgrind/clo.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/clo.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -98,7 +98,8 @@
static __inline__
fn_config* new_fnc(void)
{
- fn_config* new = (fn_config*) CLG_MALLOC(sizeof(fn_config));
+ fn_config* new = (fn_config*) CLG_MALLOC("cl.clo.nf.1",
+ sizeof(fn_config));
new->dump_before = CONFIG_DEFAULT;
new->dump_after = CONFIG_DEFAULT;
@@ -121,7 +122,8 @@
static config_node* new_config(Char* name, int length)
{
int i;
- config_node* node = (config_node*) CLG_MALLOC(sizeof(config_node) + length);
+ config_node* node = (config_node*) CLG_MALLOC("cl.clo.nc.1",
+ sizeof(config_node) + length);
for(i=0;i<length;i++) {
if (name[i] == 0) break;
@@ -588,7 +590,7 @@
}
else if (0 == VG_(strncmp)(arg, "--callgrind-out-file=", 21))
- CLG_(clo).out_format = VG_(strdup)(arg+21);
+ CLG_(clo).out_format = VG_(strdup)("cl.clo.pclo.1", arg+21);
else if (0 == VG_(strcmp)(arg, "--mangle-names=yes"))
CLG_(clo).mangle_names = True;
Modified: branches/YARD/callgrind/command.c
===================================================================
--- branches/YARD/callgrind/command.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/command.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -67,7 +67,7 @@
/* name of command file */
size = VG_(strlen)(dir) + VG_(strlen)(DEFAULT_COMMANDNAME) +10;
- command_file = (char*) CLG_MALLOC(size);
+ command_file = (char*) CLG_MALLOC("cl.command.sc.1", size);
CLG_ASSERT(command_file != 0);
VG_(sprintf)(command_file, "%s/%s.%d",
dir, DEFAULT_COMMANDNAME, thisPID);
@@ -76,13 +76,13 @@
* KCachegrind releases, as it doesn't use ".pid" to distinguish
* different callgrind instances from same base directory.
*/
- command_file2 = (char*) CLG_MALLOC(size);
+ command_file2 = (char*) CLG_MALLOC("cl.command.sc.2", size);
CLG_ASSERT(command_file2 != 0);
VG_(sprintf)(command_file2, "%s/%s",
dir, DEFAULT_COMMANDNAME);
size = VG_(strlen)(dir) + VG_(strlen)(DEFAULT_RESULTNAME) +10;
- result_file = (char*) CLG_MALLOC(size);
+ result_file = (char*) CLG_MALLOC("cl.command.sc.3", size);
CLG_ASSERT(result_file != 0);
VG_(sprintf)(result_file, "%s/%s.%d",
dir, DEFAULT_RESULTNAME, thisPID);
@@ -90,12 +90,13 @@
/* If we get a command from a command file without .pid, use
* a result file without .pid suffix
*/
- result_file2 = (char*) CLG_MALLOC(size);
+ result_file2 = (char*) CLG_MALLOC("cl.command.sc.4", size);
CLG_ASSERT(result_file2 != 0);
VG_(sprintf)(result_file2, "%s/%s",
dir, DEFAULT_RESULTNAME);
- info_file = (char*) CLG_MALLOC(VG_(strlen)(DEFAULT_INFONAME) + 10);
+ info_file = (char*) CLG_MALLOC("cl.command.sc.5",
+ VG_(strlen)(DEFAULT_INFONAME) + 10);
CLG_ASSERT(info_file != 0);
VG_(sprintf)(info_file, "%s.%d", DEFAULT_INFONAME, thisPID);
Modified: branches/YARD/callgrind/context.c
===================================================================
--- branches/YARD/callgrind/context.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/context.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -43,7 +43,8 @@
CLG_ASSERT(s != 0);
s->size = N_FNSTACK_INITIAL_ENTRIES;
- s->bottom = (fn_node**) CLG_MALLOC(s->size * sizeof(fn_node*));
+ s->bottom = (fn_node**) CLG_MALLOC("cl.context.ifs.1",
+ s->size * sizeof(fn_node*));
s->top = s->bottom;
s->bottom[0] = 0;
}
@@ -74,7 +75,8 @@
cxts.size = N_CXT_INITIAL_ENTRIES;
cxts.entries = 0;
- cxts.table = (Context**) CLG_MALLOC(cxts.size * sizeof(Context*));
+ cxts.table = (Context**) CLG_MALLOC("cl.context.ict.1",
+ cxts.size * sizeof(Context*));
for (i = 0; i < cxts.size; i++)
cxts.table[i] = 0;
@@ -93,7 +95,8 @@
UInt new_idx;
new_size = 2* cxts.size +3;
- new_table = (Context**) CLG_MALLOC(new_size * sizeof(Context*));
+ new_table = (Context**) CLG_MALLOC("cl.context.rct.1",
+ new_size * sizeof(Context*));
if (!new_table) return;
@@ -190,7 +193,8 @@
if (10 * cxts.entries / cxts.size > 8)
resize_cxt_table();
- new = (Context*) CLG_MALLOC(sizeof(Context)+sizeof(fn_node*)*size);
+ new = (Context*) CLG_MALLOC("cl.context.nc.1",
+ sizeof(Context)+sizeof(fn_node*)*size);
// hash value calculation similar to cxt_hash_val(), but additionally
// copying function pointers in one run
@@ -298,7 +302,8 @@
fn_entries = CLG_(current_fn_stack).top - CLG_(current_fn_stack).bottom;
if (fn_entries == CLG_(current_fn_stack).size-1) {
int new_size = CLG_(current_fn_stack).size *2;
- fn_node** new = (fn_node**) CLG_MALLOC(new_size * sizeof(fn_node*));
+ fn_node** new = (fn_node**) CLG_MALLOC("cl.context.pc.1",
+ new_size * sizeof(fn_node*));
int i;
for(i=0;i<CLG_(current_fn_stack).size;i++)
new[i] = CLG_(current_fn_stack).bottom[i];
Modified: branches/YARD/callgrind/costs.c
===================================================================
--- branches/YARD/callgrind/costs.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/costs.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -43,7 +43,8 @@
if (!cost_chunk_current ||
(cost_chunk_current->size - cost_chunk_current->used < size)) {
- CostChunk* cc = (CostChunk*) CLG_MALLOC(sizeof(CostChunk) +
+ CostChunk* cc = (CostChunk*) CLG_MALLOC("cl.costs.gc.1",
+ sizeof(CostChunk) +
COSTCHUNK_SIZE * sizeof(ULong));
cc->size = COSTCHUNK_SIZE;
cc->used = 0;
Modified: branches/YARD/callgrind/debug.c
===================================================================
--- branches/YARD/callgrind/debug.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/debug.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -429,10 +429,10 @@
VG_(printf)("\n");
}
-void* CLG_(malloc)(UWord s, char* f)
+void* CLG_(malloc)(HChar* cc, UWord s, char* f)
{
CLG_DEBUG(3, "Malloc(%lu) in %s.\n", s, f);
- return VG_(malloc)(s);
+ return VG_(malloc)(cc,s);
}
#else /* CLG_ENABLE_DEBUG */
Modified: branches/YARD/callgrind/dump.c
===================================================================
--- branches/YARD/callgrind/dump.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/dump.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -105,7 +105,8 @@
CLG_(stat).distinct_fns +
CLG_(stat).context_counter;
CLG_ASSERT(dump_array == 0);
- dump_array = (Bool*) CLG_MALLOC(dump_array_size * sizeof(Bool));
+ dump_array = (Bool*) CLG_MALLOC("cl.dump.ida.1",
+ dump_array_size * sizeof(Bool));
obj_dumped = dump_array;
file_dumped = obj_dumped + CLG_(stat).distinct_objs;
fn_dumped = file_dumped + CLG_(stat).distinct_files;
@@ -1218,7 +1219,8 @@
/* allocate bbcc array, insert BBCCs and sort */
prepare_ptr = array =
- (BBCC**) CLG_MALLOC((prepare_count+1) * sizeof(BBCC*));
+ (BBCC**) CLG_MALLOC("cl.dump.pd.1",
+ (prepare_count+1) * sizeof(BBCC*));
CLG_(forall_bbccs)(hash_addPtr);
@@ -1693,12 +1695,13 @@
i++;
}
i = lastSlash;
- out_directory = (Char*) CLG_MALLOC(i+1);
+ out_directory = (Char*) CLG_MALLOC("cl.dump.init_dumps.1", i+1);
VG_(strncpy)(out_directory, out_file, i);
out_directory[i] = 0;
/* allocate space big enough for final filenames */
- filename = (Char*) CLG_MALLOC(VG_(strlen)(out_file)+32);
+ filename = (Char*) CLG_MALLOC("cl.dump.init_dumps.2",
+ VG_(strlen)(out_file)+32);
CLG_ASSERT(filename != 0);
/* Make sure the output base file can be written.
Modified: branches/YARD/callgrind/events.c
===================================================================
--- branches/YARD/callgrind/events.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/events.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -46,7 +46,7 @@
et = &(eventtype[eventtype_count]);
et->id = eventtype_count;
- et->name = (UChar*) VG_(strdup)(name);
+ et->name = (UChar*) VG_(strdup)("cl.events.re.1", name);
et->description = 0;
eventtype_count++;
@@ -77,7 +77,8 @@
{
EventSet* es;
- es = (EventSet*) CLG_MALLOC(sizeof(EventSet) +
+ es = (EventSet*) CLG_MALLOC("cl.events.geSet.1",
+ sizeof(EventSet) +
capacity * sizeof(EventSetEntry));
es->capacity = capacity;
es->size = 0;
@@ -499,7 +500,8 @@
CLG_ASSERT(es != 0);
- em = (EventMapping*) CLG_MALLOC(sizeof(EventMapping) +
+ em = (EventMapping*) CLG_MALLOC("cl.events.geMapping.1",
+ sizeof(EventMapping) +
es->capacity * sizeof(Int));
em->capacity = es->capacity;
em->size = 0;
Modified: branches/YARD/callgrind/fn.c
===================================================================
--- branches/YARD/callgrind/fn.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/fn.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -186,8 +186,8 @@
Int i;
obj_node* new;
- new = (obj_node*) CLG_MALLOC(sizeof(obj_node));
- new->name = di ? VG_(strdup)( VG_(seginfo_filename)(di) )
+ new = (obj_node*) CLG_MALLOC("cl.fn.non.1", sizeof(obj_node));
+ new->name = di ? VG_(strdup)( "cl.fn.non.2",VG_(seginfo_filename)(di) )
: anonymous_obj;
for (i = 0; i < N_FILE_ENTRIES; i++) {
new->files[i] = NULL;
@@ -244,8 +244,9 @@
obj_node* obj, file_node* next)
{
Int i;
- file_node* new = (file_node*) CLG_MALLOC(sizeof(file_node));
- new->name = VG_(strdup)(filename);
+ file_node* new = (file_node*) CLG_MALLOC("cl.fn.nfn.1",
+ sizeof(file_node));
+ new->name = VG_(strdup)("cl.fn.nfn.2", filename);
for (i = 0; i < N_FN_ENTRIES; i++) {
new->fns[i] = NULL;
}
@@ -286,8 +287,9 @@
fn_node* new_fn_node(Char fnname[FILENAME_LEN],
file_node* file, fn_node* next)
{
- fn_node* new = (fn_node*) CLG_MALLOC(sizeof(fn_node));
- new->name = VG_(strdup)(fnname);
+ fn_node* new = (fn_node*) CLG_MALLOC("cl.fn.nfnnd.1",
+ sizeof(fn_node));
+ new->name = VG_(strdup)("cl.fn.nfnnd.2", fnname);
CLG_(stat).distinct_fns++;
new->number = CLG_(stat).distinct_fns;
@@ -574,7 +576,8 @@
if (a->size <= CLG_(stat).distinct_fns)
a->size = CLG_(stat).distinct_fns+1;
- a->array = (UInt*) CLG_MALLOC(a->size * sizeof(UInt));
+ a->array = (UInt*) CLG_MALLOC("cl.fn.gfe.1",
+ a->size * sizeof(UInt));
for(i=0;i<a->size;i++)
a->array[i] = 0;
}
@@ -617,7 +620,7 @@
CLG_DEBUG(0, "Resize fn_active_array: %d => %d\n",
current_fn_active.size, newsize);
- new = (UInt*) CLG_MALLOC(newsize * sizeof(UInt));
+ new = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
for(i=0;i<current_fn_active.size;i++)
new[i] = current_fn_active.array[i];
while(i<newsize)
Modified: branches/YARD/callgrind/global.h
===================================================================
--- branches/YARD/callgrind/global.h 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/global.h 2008-09-06 18:45:50 UTC (rev 8565)
@@ -868,14 +868,14 @@
void CLG_(print_addr)(Addr addr);
void CLG_(print_addr_ln)(Addr addr);
-void* CLG_(malloc)(UWord s, char* f);
+void* CLG_(malloc)(HChar* cc, UWord s, char* f);
void* CLG_(free)(void* p, char* f);
#if 0
-#define CLG_MALLOC(x) CLG_(malloc)(x,__FUNCTION__)
-#define CLG_FREE(p) CLG_(free)(p,__FUNCTION__)
+#define CLG_MALLOC(_cc,x) CLG_(malloc)((_cc),x,__FUNCTION__)
+#define CLG_FREE(p) CLG_(free)(p,__FUNCTION__)
#else
-#define CLG_MALLOC(x) VG_(malloc)(x)
-#define CLG_FREE(p) VG_(free)(p)
+#define CLG_MALLOC(_cc,x) VG_(malloc)((_cc),x)
+#define CLG_FREE(p) VG_(free)(p)
#endif
#endif /* CLG_GLOBAL */
Modified: branches/YARD/callgrind/jumps.c
===================================================================
--- branches/YARD/callgrind/jumps.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/jumps.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -46,7 +46,8 @@
jccs->size = N_JCC_INITIAL_ENTRIES;
jccs->entries = 0;
- jccs->table = (jCC**) CLG_MALLOC(jccs->size * sizeof(jCC*));
+ jccs->table = (jCC**) CLG_MALLOC("cl.jumps.ijh.1",
+ jccs->size * sizeof(jCC*));
jccs->spontaneous = 0;
for (i = 0; i < jccs->size; i++)
@@ -89,7 +90,8 @@
jCC *curr_jcc, *next_jcc;
new_size = 2* current_jccs.size +3;
- new_table = (jCC**) CLG_MALLOC(new_size * sizeof(jCC*));
+ new_table = (jCC**) CLG_MALLOC("cl.jumps.rjt.1",
+ new_size * sizeof(jCC*));
if (!new_table) return;
@@ -145,7 +147,7 @@
if (10 * current_jccs.entries / current_jccs.size > 8)
resize_jcc_table();
- new = (jCC*) CLG_MALLOC(sizeof(jCC));
+ new = (jCC*) CLG_MALLOC("cl.jumps.nj.1", sizeof(jCC));
new->from = from;
new->jmp = jmp;
Modified: branches/YARD/callgrind/sim.c
===================================================================
--- branches/YARD/callgrind/sim.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/sim.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -214,7 +214,8 @@
c->sectored ? ", sectored":"");
}
- c->tags = (UWord*) CLG_MALLOC(sizeof(UWord) * c->sets * c->assoc);
+ c->tags = (UWord*) CLG_MALLOC("cl.sim.cs_ic.1",
+ sizeof(UWord) * c->sets * c->assoc);
if (clo_collect_cacheuse)
cacheuse_initcache(c);
else
@@ -611,12 +612,15 @@
unsigned int start_mask, start_val;
unsigned int end_mask, end_val;
- c->use = CLG_MALLOC(sizeof(line_use) * c->sets * c->assoc);
- c->loaded = CLG_MALLOC(sizeof(line_loaded) * c->sets * c->assoc);
- c->line_start_mask = CLG_MALLOC(sizeof(int) * c->line_size);
- c->line_end_mask = CLG_MALLOC(sizeof(int) * c->line_size);
+ c->use = CLG_MALLOC("cl.sim.cu_ic.1",
+ sizeof(line_use) * c->sets * c->assoc);
+ c->loaded = CLG_MALLOC("cl.sim.cu_ic.2",
+ sizeof(line_loaded) * c->sets * c->assoc);
+ c->line_start_mask = CLG_MALLOC("cl.sim.cu_ic.3",
+ sizeof(int) * c->line_size);
+ c->line_end_mask = CLG_MALLOC("cl.sim.cu_ic.4",
+ sizeof(int) * c->line_size);
-
c->line_size_mask = c->line_size-1;
/* Meaning of line_start_mask/line_end_mask
@@ -1614,7 +1618,7 @@
{
int i1, i2, i3;
int i;
- char *opt = VG_(strdup)(orig_opt);
+ char *opt = VG_(strdup)("cl.sim.po.1", orig_opt);
i = i1 = opt_len;
Modified: branches/YARD/callgrind/threads.c
===================================================================
--- branches/YARD/callgrind/threads.c 2008-09-06 18:38:07 UTC (rev 8564)
+++ branches/YARD/callgrind/threads.c 2008-09-06 18:45:50 UTC (rev 8565)
@@ -100,7 +100,8 @@
{
thread_info* t;
- t = (thread_info*) CLG_MALLOC(sizeof(thread_info));
+ t = (thread_info*) CLG_MALLOC("cl.threads.nt.1",
+ sizeof(thread_info));
/* init state */
CLG_(init_exec_stack)( &(t->states) );
@@ -323,7 +324,8 @@
static exec_state* new_exec_state(Int sigNum)
{
exec_state* es;
- es = (exec_state*) CLG_MALLOC(sizeof(exec_state));
+ es = (exec_state*) CLG_MALLOC("cl.threads.nes.1",
+ sizeof(exec_state));
/* allocate real cost space: needed as incremented by
* simulation functions */
|
