ccv_nnc_dynamic

Bug Summary

File:	nnc/ccv_nnc_dynamic_graph.c
Warning:	line 653, column 9 Branch condition evaluates to a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ccv_nnc_dynamic_graph.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +sse2 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -fcoverage-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -resource-dir /usr/local/lib/clang/19 -I ../ -I /usr/local/cuda/include -D HAVE_CBLAS -D HAVE_LIBPNG -D HAVE_LIBJPEG -D HAVE_FFTW3 -D HAVE_PTHREAD -D HAVE_LIBLINEAR -D HAVE_TESSERACT -D HAVE_AVCODEC -D HAVE_AVFORMAT -D HAVE_AVUTIL -D HAVE_SWSCALE -D HAVE_SSE2 -D HAVE_GSL -D HAVE_CUDA -D HAVE_CUDNN -D HAVE_NCCL -D USE_SYSTEM_CUB -I /usr/local/include -internal-isystem /usr/local/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/liu/actions-runner/_work/ccv/ccv/_analyze/2026-09-05-142805-2220666-1 -x c ccv_nnc_dynamic_graph.c
1#include "ccv_nnc.h"
2#include "ccv_nnc_easy.h"
3#include "ccv_nnc_internal.h"
4#include "ccv_nnc_easy.h"
5#include "ccv_internal.h"
6#include "_ccv_nnc_dynamic_graph.h"
7#ifdef HAVE_MPS
8#include "mps/ccv_nnc_mps.h"
9#endif

11// MARK - Level-4 API

13ccv_nnc_dynamic_graph_t* ccv_nnc_dynamic_graph_new(void)
14{
ccv_nnc_dynamic_graph_t* graph = ccmallocmalloc(sizeof(ccv_nnc_dynamic_graph_t));
graph->no_grad = 0;
graph->reuse_var = -1;
graph->vars = ccv_array_new(sizeof(ccv_nnc_tensor_variable_t), 1, 0);
graph->binds = ccv_array_new(sizeof(ccv_nnc_tensor_variable_graph_bind_t), 1, 0);
graph->tape = ccv_nnc_symbolic_graph_new();
graph->xpu_alloc.mp_hdr = -1;
graph->xpu_alloc.freed = kh_init(dy_str)kh_init_dy_str();
graph->xpu_alloc.allocd = kh_init(dy_alloc)kh_init_dy_alloc();
// These may not be used as frequent, init as needed.
graph->stateful_execs = 0;
graph->reuse_stateful_exec = -1;
graph->stream_map = 0;
graph->ws = 0;
return graph;
30}

32static void _ccv_nnc_tensor_variable_wait_fast_fence(ccv_nnc_tensor_view_t* const tensor_view)
33{
34#ifdef HAVE_MPS
ccv_nnc_tensor_t* const tensor = (ccv_nnc_tensor_t*)CCV_NNC_TENSOR_VIEW(tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(tensor_view) & ~(uintptr_t
)1));
if (CCV_TENSOR_GET_MEMORY(tensor->info.type)((tensor->info.type) & 0x3) == CCV_TENSOR_CPU_MEMORY)
ccv_nnc_mps_tensor_fast_fence_wait(tensor);
38#endif
39}

41static void _ccv_nnc_tensor_variable_free(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, const int zeroing)
42{
const int index = tensor_variable->index;
if (tensor_variable->tensor_view)
{
_ccv_nnc_tensor_variable_wait_fast_fence(tensor_variable->tensor_view);
if (tensor_variable->destructor_hook.func)
	tensor_variable->destructor_hook.func(graph, (ccv_nnc_tensor_t*)tensor_variable->tensor_view, tensor_variable->destructor_hook.context);
if (!CCV_NNC_IS_EXTERN_TENSOR_VIEW(tensor_variable->tensor_view)((uintptr_t)(tensor_variable->tensor_view) & 1))
{
	if (CCV_IS_TENSOR_VIEW(tensor_variable->tensor_view)((*(int*)(tensor_variable->tensor_view)) & CCV_TENSOR_VIEW
))
		ccv_nnc_tensor_view_free(tensor_variable->tensor_view);
	else {
		if (!tensor_variable->alias_index_ref && // Return this memory to the graph.
			CCV_TENSOR_GET_MEMORY(tensor_variable->tensor_view->info.type)((tensor_variable->tensor_view->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY && tensor_variable->tensor_view->data.u8)
			ccv_nnc_xpu_free(&graph->xpu_alloc, tensor_variable->tensor_view->data.u8);
		ccv_nnc_tensor_free((ccv_nnc_tensor_t*)tensor_variable->tensor_view);
	}
}
}
ccfreefree(tensor_variable);
if (zeroing)
*(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(index))) = 0;
int i;
for (i = graph->vars->rnum - 1; i >= 0; i--)
if (*(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, i)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(i))) != 0)
{
	graph->vars->rnum = i + 1;
	break;
}
if (index < graph->vars->rnum &&
(index < graph->reuse_var || graph->reuse_var < 0))
graph->reuse_var = index;
else if (graph->reuse_var >= graph->vars->rnum)
graph->reuse_var = -1;
76}

78static void _ccv_nnc_tensor_variable_graph_bind_free(ccv_nnc_dynamic_graph_t* const graph, ccv_nnc_tensor_variable_graph_bind_t* const bind, const int zeroing)
79{
bind->index = CCV_NNC_TENSOR_NO_VARIABLE;
if (bind->sources)
ccv_array_free(bind->sources);
if (bind->destinations)
ccv_array_free(bind->destinations);
if (bind->tensor_view)
{
_ccv_nnc_tensor_variable_wait_fast_fence(bind->tensor_view);
if (bind->destructor_hook.func)
	bind->destructor_hook.func(graph, (ccv_nnc_tensor_t*)bind->tensor_view, bind->destructor_hook.context);
if (!CCV_NNC_IS_EXTERN_TENSOR_VIEW(bind->tensor_view)((uintptr_t)(bind->tensor_view) & 1))
{
	if (CCV_IS_TENSOR_VIEW(bind->tensor_view)((*(int*)(bind->tensor_view)) & CCV_TENSOR_VIEW))
		ccv_nnc_tensor_view_free(bind->tensor_view);
	else {
		if (!bind->alias_ref && // Return this memory to the graph.
			CCV_TENSOR_GET_MEMORY(bind->tensor_view->info.type)((bind->tensor_view->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY && bind->tensor_view->data.u8)
			ccv_nnc_xpu_free(&graph->xpu_alloc, bind->tensor_view->data.u8);
		ccv_nnc_tensor_free((ccv_nnc_tensor_t*)bind->tensor_view);
	}
}
}
if (zeroing)
{
bind->sources = 0;
bind->destinations = 0;
bind->tensor_view = 0;
bind->destructor_hook.func = 0;
bind->destructor_hook.context = 0;
}
110}

112void ccv_nnc_dynamic_graph_free(ccv_nnc_dynamic_graph_t* const graph)
113{
int i;
for (i = 0; i < graph->vars->rnum; i++)
{
ccv_nnc_tensor_variable_t tensor_variable = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, i)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(i)));
if (tensor_variable)
	_ccv_nnc_tensor_variable_free(graph, tensor_variable, 0);
}
ccv_array_free(graph->vars);
for (i = 0; i < graph->binds->rnum; i++)
_ccv_nnc_tensor_variable_graph_bind_free(graph, (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, i)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(i))), 0);
ccv_array_free(graph->binds);
ccv_nnc_symbolic_graph_free(graph->tape);
if (graph->ws)
ccv_array_free(graph->ws);
if (graph->stateful_execs)
{
for (i = 0; i < graph->stateful_execs->rnum; i++)
{
	ccv_nnc_stateful_exec_t* const stateful_exec = *(ccv_nnc_stateful_exec_t**)ccv_array_get(graph->stateful_execs, i)((void*)(((char*)((graph->stateful_execs)->data)) + (size_t
)(graph->stateful_execs)->rsize * (size_t)(i)));
	if (stateful_exec)
		ccfreefree(stateful_exec);
}
ccv_array_free(graph->stateful_execs);
}
if (graph->stream_map)
{
khiter_t k;
for (k = kh_begin(graph->stream_map)(khint_t)(0); k != kh_end(graph->stream_map)((graph->stream_map)->n_buckets); ++k)
{
	if (!kh_exist(graph->stream_map, k)(!(((graph->stream_map)->flags[(k)>>4]>>(((
k)&0xfU)<<1))&3)))
		continue;
	ccv_nnc_stream_context_t* const stream = kh_val(graph->stream_map, k)((graph->stream_map)->vals[k]);
	ccv_nnc_stream_context_free(stream);
}
kh_destroy(stream_map, graph->stream_map)kh_destroy_stream_map(graph->stream_map);
}
ccv_nnc_xpu_alloc_destroy(&graph->xpu_alloc);
ccfreefree(graph);
152}

154void ccv_nnc_tensor_variable_set(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, ccv_nnc_tensor_t* const tensor)
155{
assert(!tensor_variable->alias_index_ref)((void) sizeof ((!tensor_variable->alias_index_ref) ? 1 : 0
), __extension__ ({ if (!tensor_variable->alias_index_ref)
 ; else __assert_fail ("!tensor_variable->alias_index_ref"
, "ccv_nnc_dynamic_graph.c", 156, __extension__ __PRETTY_FUNCTION__
); }));
if (tensor_variable->tensor_view && !CCV_NNC_IS_EXTERN_TENSOR_VIEW(tensor_variable->tensor_view)((uintptr_t)(tensor_variable->tensor_view) & 1))
{
assert(!CCV_IS_TENSOR_VIEW(tensor_variable->tensor_view))((void) sizeof ((!((*(int*)(tensor_variable->tensor_view))
 & CCV_TENSOR_VIEW)) ? 1 : 0), __extension__ ({ if (!((*(
int*)(tensor_variable->tensor_view)) & CCV_TENSOR_VIEW
)) ; else __assert_fail ("!CCV_IS_TENSOR_VIEW(tensor_variable->tensor_view)"
, "ccv_nnc_dynamic_graph.c", 159, __extension__ __PRETTY_FUNCTION__
); }));
ccv_nnc_tensor_free((ccv_nnc_tensor_t*)tensor_variable->tensor_view);
}
tensor_variable->info = tensor->info;
tensor_variable->tensor_view = (ccv_nnc_tensor_view_t*)((uintptr_t)tensor | 1);
164}

166void ccv_nnc_tensor_variable_destructor_hook(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, ccv_nnc_tensor_variable_destructor_f func, void* const context)
167{
tensor_variable->destructor_hook.func = func;
tensor_variable->destructor_hook.context = context;
170}

172inline static void _ccv_nnc_tensor_variable_init(ccv_nnc_dynamic_graph_t* const graph, ccv_nnc_tensor_variable_t tensor_variable, const ccv_nnc_tensor_param_t info)
173{
tensor_variable->alias_index_ref = 0;
tensor_variable->alias_off = 0;
tensor_variable->destructor_hook.func = 0;
tensor_variable->destructor_hook.context = 0;
tensor_variable->info = info;
tensor_variable->symbol = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
tensor_variable->tensor_view = 0;
if (graph->reuse_var >= 0)
{
const int reuse_var = graph->reuse_var;
assert(reuse_var < graph->vars->rnum)((void) sizeof ((reuse_var < graph->vars->rnum) ? 1 :
 0), __extension__ ({ if (reuse_var < graph->vars->rnum
) ; else __assert_fail ("reuse_var < graph->vars->rnum"
, "ccv_nnc_dynamic_graph.c", 184, __extension__ __PRETTY_FUNCTION__
); }));
tensor_variable->index = reuse_var;
*(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, reuse_var)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(reuse_var))) = tensor_variable;
int i;
graph->reuse_var = -1;
for (i = reuse_var + 1; i < graph->vars->rnum && graph->reuse_var < 0; i++)
	if (*(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, i)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(i))) == 0)
		graph->reuse_var = i;
} else {
tensor_variable->index = graph->vars->rnum;
ccv_array_push(graph->vars, &tensor_variable);
}
196}

198ccv_nnc_tensor_variable_t ccv_nnc_tensor_variable_new_impl(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_param_t info)
199{
ccv_nnc_tensor_variable_t tensor_variable = ccmallocmalloc(sizeof(struct ccv_nnc_tensor_variable_s));
tensor_variable->type = CCV_NNC_TENSOR_VARIABLE;
_ccv_nnc_tensor_variable_init(graph, tensor_variable, info);
return tensor_variable;
204}

206ccv_nnc_tensor_variable_t ccv_nnc_tensor_constant_new_impl(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_param_t info)
207{
ccv_nnc_tensor_variable_t tensor_variable = ccmallocmalloc(sizeof(struct ccv_nnc_tensor_variable_s));
tensor_variable->type = CCV_NNC_TENSOR_CONSTANT;
_ccv_nnc_tensor_variable_init(graph, tensor_variable, info);
return tensor_variable;
212}

214int ccv_nnc_tensor_variable_is_constant(const ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable)
215{
return tensor_variable->type == CCV_NNC_TENSOR_CONSTANT;
217}

219ccv_nnc_tensor_param_t ccv_nnc_tensor_variable_params(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable)
220{
return tensor_variable->info;
222}

224ccv_nnc_tensor_variable_t ccv_nnc_tensor_variable_alias_new(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, const int ofs[CCV_NNC_MAX_DIM_ALLOC(12)], const int stride[CCV_NNC_MAX_DIM_ALLOC(12)], const ccv_nnc_tensor_param_t info)
225{
ccv_nnc_tensor_variable_t variable_alias = ccmallocmalloc(sizeof(struct ccv_nnc_tensor_variable_s));
variable_alias->type = tensor_variable->type;
// If the tensor variable is an alias itself, we point directly to its original.
if (tensor_variable->alias_index_ref)
{
variable_alias->alias_index_ref = tensor_variable->alias_index_ref;
// The tensor variable need to be fully specified if I am doing alias an alias.
assert(!ccv_nnc_is_tensor_auto(tensor_variable->info))((void) sizeof ((!ccv_nnc_is_tensor_auto(tensor_variable->
info)) ? 1 : 0), __extension__ ({ if (!ccv_nnc_is_tensor_auto
(tensor_variable->info)) ; else __assert_fail ("!ccv_nnc_is_tensor_auto(tensor_variable->info)"
, "ccv_nnc_dynamic_graph.c", 233, __extension__ __PRETTY_FUNCTION__
); }));
int i;
int no_stride = 1;
for (i = 0; no_stride && i < CCV_NNC_MAX_DIM_ALLOC(12); i++)
	no_stride = (tensor_variable->stride[i] == 0);
int stride_from_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
int* to_stride;
if (no_stride)
{
	ccv_nnc_tensor_get_stride(tensor_variable->info.dim, stride_from_dim);
	to_stride = stride_from_dim;
} else
	to_stride = tensor_variable->stride;
// If we provide stride, or reshape to a different size, assert the tensor variable itself is contiguous (otherwise we cannot satisfy the reshape requirements).
const int different_dim = ccv_nnc_tensor_nd(info.dim) != ccv_nnc_tensor_nd(tensor_variable->info.dim);
if (different_dim || (stride[0] != 0 && memcmp(stride, to_stride, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12)) != 0))
	{ assert(ccv_nnc_tensor_view_is_contiguous(tensor_variable->info.dim, to_stride))((void) sizeof ((ccv_nnc_tensor_view_is_contiguous(tensor_variable
->info.dim, to_stride)) ? 1 : 0), __extension__ ({ if (ccv_nnc_tensor_view_is_contiguous
(tensor_variable->info.dim, to_stride)) ; else __assert_fail
 ("ccv_nnc_tensor_view_is_contiguous(tensor_variable->info.dim, to_stride)"
, "ccv_nnc_dynamic_graph.c", 249, __extension__ __PRETTY_FUNCTION__
); })); }
// Need to compute alias off, that is the alias off of the tensor variable plus its ofs.
const off_t off = ccv_nnc_tensor_view_offset(tensor_variable->info.datatype, to_stride, tensor_variable->ofs);
variable_alias->alias_off = tensor_variable->alias_off + off;
// If we don't provide stride, copy the stride from previous variable.
if (stride[0] == 0)
{
	if (different_dim)
		ccv_nnc_tensor_get_stride(info.dim, variable_alias->stride);
	else
		memcpy(variable_alias->stride, to_stride, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12));
} else
	memcpy(variable_alias->stride, stride, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12));
} else {
variable_alias->alias_index_ref = tensor_variable->index + 1;
variable_alias->alias_off = 0;
memcpy(variable_alias->stride, stride, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12));
}
variable_alias->info = info;
variable_alias->symbol = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
variable_alias->destructor_hook.func = 0;
variable_alias->destructor_hook.context = 0;
variable_alias->tensor_view = 0;
memcpy(variable_alias->ofs, ofs, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12));
if (graph->reuse_var >= 0)
{
const int reuse_var = graph->reuse_var;
assert(reuse_var < graph->vars->rnum)((void) sizeof ((reuse_var < graph->vars->rnum) ? 1 :
 0), __extension__ ({ if (reuse_var < graph->vars->rnum
) ; else __assert_fail ("reuse_var < graph->vars->rnum"
, "ccv_nnc_dynamic_graph.c", 276, __extension__ __PRETTY_FUNCTION__
); }));
variable_alias->index = reuse_var;
*(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, reuse_var)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(reuse_var))) = variable_alias;
int i;
graph->reuse_var = -1;
for (i = reuse_var + 1; i < graph->vars->rnum && graph->reuse_var < 0; i++)
	if (*(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, i)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(i))) == 0)
		graph->reuse_var = i;
} else {
variable_alias->index = graph->vars->rnum;
ccv_array_push(graph->vars, &variable_alias);
}
return variable_alias;
289}

291int ccv_nnc_tensor_variable_alias_params(const ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, int ofs[CCV_NNC_MAX_DIM_ALLOC(12)], int stride[CCV_NNC_MAX_DIM_ALLOC(12)])
292{
if (!tensor_variable->alias_index_ref)
return -1;
if (ofs)
memcpy(ofs, tensor_variable->ofs, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12));
if (stride)
memcpy(stride, tensor_variable->stride, sizeof(int) * CCV_NNC_MAX_DIM_ALLOC(12));
return 0;
300}

302ccv_nnc_tensor_t* ccv_nnc_tensor_from_variable_impl(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, ccv_nnc_stream_context_t* const stream_context)
303{
if (tensor_variable->tensor_view)
{
if (tensor_variable->alias_index_ref)
{
	const int alias_index = tensor_variable->alias_index_ref - 1;
	assert(alias_index >= 0)((void) sizeof ((alias_index >= 0) ? 1 : 0), __extension__
 ({ if (alias_index >= 0) ; else __assert_fail ("alias_index >= 0"
, "ccv_nnc_dynamic_graph.c", 309, __extension__ __PRETTY_FUNCTION__
); }));
	ccv_nnc_tensor_variable_t variable_to = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, alias_index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(alias_index)));
	if (CCV_IS_TENSOR_VIEW(tensor_variable->tensor_view)((*(int*)(tensor_variable->tensor_view)) & CCV_TENSOR_VIEW
))
	{
		ccv_nnc_tensor_view_t* const tv = tensor_variable->tensor_view;
		// We cannot have an alias with custom set tensor, otherwise the pointer update is invalid.
		assert(!CCV_NNC_IS_EXTERN_TENSOR_VIEW(tv))((void) sizeof ((!((uintptr_t)(tv) & 1)) ? 1 : 0), __extension__
 ({ if (!((uintptr_t)(tv) & 1)) ; else __assert_fail ("!CCV_NNC_IS_EXTERN_TENSOR_VIEW(tv)"
, "ccv_nnc_dynamic_graph.c", 315, __extension__ __PRETTY_FUNCTION__
); }));
		// Update the tensor_view pointer every time access it, because the underlying variable it alias to have changed.
		ccv_nnc_tensor_data(CCV_NNC_TENSOR_VIEW(variable_to->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(variable_to->tensor_view
) & ~(uintptr_t)1))->info, CCV_NNC_TENSOR_VIEW(variable_to->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(variable_to->tensor_view
) & ~(uintptr_t)1))->data.u8, tv->off + tensor_variable->alias_off, &tv->data, &tv->dataof);
	} else {
		ccv_nnc_tensor_t* const tv = (ccv_nnc_tensor_t*)tensor_variable->tensor_view;
		// We cannot have an alias with custom set tensor, otherwise the pointer update is invalid.
		assert(!CCV_NNC_IS_EXTERN_TENSOR_VIEW(tv))((void) sizeof ((!((uintptr_t)(tv) & 1)) ? 1 : 0), __extension__
 ({ if (!((uintptr_t)(tv) & 1)) ; else __assert_fail ("!CCV_NNC_IS_EXTERN_TENSOR_VIEW(tv)"
, "ccv_nnc_dynamic_graph.c", 321, __extension__ __PRETTY_FUNCTION__
); }));
		// Update the tensor_view pointer every time access it, because the underlying variable it alias to have changed.
		ccv_nnc_tensor_data(CCV_NNC_TENSOR_VIEW(variable_to->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(variable_to->tensor_view
) & ~(uintptr_t)1))->info, CCV_NNC_TENSOR_VIEW(variable_to->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(variable_to->tensor_view
) & ~(uintptr_t)1))->data.u8, tensor_variable->alias_off, &tv->data, &tv->dataof);
	}
}
return (ccv_nnc_tensor_t*)CCV_NNC_TENSOR_VIEW(tensor_variable->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(tensor_variable->tensor_view
) & ~(uintptr_t)1));
}
if (!tensor_variable->alias_index_ref)
{
// If we haven't allocated tensor_variable, we cannot allocate them now (because no shape specified), return 0.
if (ccv_nnc_is_tensor_auto(tensor_variable->info))
	return 0;
void* ptr = 0;
const size_t data_size = ccv_nnc_tensor_data_size(tensor_variable->info);
if (CCV_TENSOR_GET_MEMORY(tensor_variable->info.type)((tensor_variable->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY && data_size > 0)
	ptr = ccv_nnc_xpu_alloc(&graph->xpu_alloc, CCV_TENSOR_GET_DEVICE_ID(tensor_variable->info.type)(((tensor_variable->info.type) & 0xfff00) >> 8), stream_context, data_size);
tensor_variable->tensor_view = (ccv_nnc_tensor_view_t*)ccv_nnc_tensor_new(ptr, tensor_variable->info, 0);
if (tensor_variable->info.dim[0] > 0)
	{ assert(tensor_variable->tensor_view->data.u8)((void) sizeof ((tensor_variable->tensor_view->data.u8)
 ? 1 : 0), __extension__ ({ if (tensor_variable->tensor_view
->data.u8) ; else __assert_fail ("tensor_variable->tensor_view->data.u8"
, "ccv_nnc_dynamic_graph.c", 339, __extension__ __PRETTY_FUNCTION__
); })); }
return (ccv_nnc_tensor_t*)tensor_variable->tensor_view;
}
const int alias_index = tensor_variable->alias_index_ref - 1;
assert(alias_index >= 0)((void) sizeof ((alias_index >= 0) ? 1 : 0), __extension__
 ({ if (alias_index >= 0) ; else __assert_fail ("alias_index >= 0"
, "ccv_nnc_dynamic_graph.c", 343, __extension__ __PRETTY_FUNCTION__
); }));
ccv_nnc_tensor_variable_t variable_to = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, alias_index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(alias_index)));
assert(!variable_to->alias_index_ref)((void) sizeof ((!variable_to->alias_index_ref) ? 1 : 0), __extension__
 ({ if (!variable_to->alias_index_ref) ; else __assert_fail
 ("!variable_to->alias_index_ref", "ccv_nnc_dynamic_graph.c"
, 345, __extension__ __PRETTY_FUNCTION__); }));
if (!variable_to->tensor_view)
{
// If we haven't allocated variable_to, we cannot allocate them now (because no shape specified), return 0.
if (ccv_nnc_is_tensor_auto(variable_to->info))
	return 0;
void* ptr = 0;
assert(variable_to->info.type == tensor_variable->info.type)((void) sizeof ((variable_to->info.type == tensor_variable
->info.type) ? 1 : 0), __extension__ ({ if (variable_to->
info.type == tensor_variable->info.type) ; else __assert_fail
 ("variable_to->info.type == tensor_variable->info.type"
, "ccv_nnc_dynamic_graph.c", 352, __extension__ __PRETTY_FUNCTION__
); }));
const size_t data_size = ccv_nnc_tensor_data_size(variable_to->info);
if (CCV_TENSOR_GET_MEMORY(variable_to->info.type)((variable_to->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY && data_size > 0)
	ptr = ccv_nnc_xpu_alloc(&graph->xpu_alloc, CCV_TENSOR_GET_DEVICE_ID(variable_to->info.type)(((variable_to->info.type) & 0xfff00) >> 8), stream_context, data_size);
variable_to->tensor_view = (ccv_nnc_tensor_view_t*)ccv_nnc_tensor_new(ptr, variable_to->info, 0);
assert(variable_to->tensor_view->data.u8)((void) sizeof ((variable_to->tensor_view->data.u8) ? 1
 : 0), __extension__ ({ if (variable_to->tensor_view->data
.u8) ; else __assert_fail ("variable_to->tensor_view->data.u8"
, "ccv_nnc_dynamic_graph.c", 357, __extension__ __PRETTY_FUNCTION__
); }));
}
int i;
int no_ofs = 1;
for (i = 0; no_ofs && i < CCV_NNC_MAX_DIM_ALLOC(12); i++)
no_ofs = (tensor_variable->ofs[i] == 0);
int no_stride = 1;
for (i = 0; no_stride && i < CCV_NNC_MAX_DIM_ALLOC(12); i++)
no_stride = (tensor_variable->stride[i] == 0);
int stride_is_packed = no_stride;
if (!no_stride) // We have stride, now if it is packed.
stride_is_packed = ccv_nnc_is_tensor_stride_packed(tensor_variable->stride, tensor_variable->info.dim);
assert(CCV_GET_DATA_TYPE_SIZE(tensor_variable->info.datatype) * ccv_nnc_tensor_count(tensor_variable->info) + tensor_variable->alias_off <= CCV_GET_DATA_TYPE_SIZE(variable_to->info.datatype) * ccv_nnc_tensor_count(variable_to->info))((void) sizeof ((_ccv_get_data_type_size[((tensor_variable->
info.datatype) & 0xFF000) >> 12] * ccv_nnc_tensor_count
(tensor_variable->info) + tensor_variable->alias_off <=
 _ccv_get_data_type_size[((variable_to->info.datatype) &
 0xFF000) >> 12] * ccv_nnc_tensor_count(variable_to->
info)) ? 1 : 0), __extension__ ({ if (_ccv_get_data_type_size
[((tensor_variable->info.datatype) & 0xFF000) >>
 12] * ccv_nnc_tensor_count(tensor_variable->info) + tensor_variable
->alias_off <= _ccv_get_data_type_size[((variable_to->
info.datatype) & 0xFF000) >> 12] * ccv_nnc_tensor_count
(variable_to->info)) ; else __assert_fail ("CCV_GET_DATA_TYPE_SIZE(tensor_variable->info.datatype) * ccv_nnc_tensor_count(tensor_variable->info) + tensor_variable->alias_off <= CCV_GET_DATA_TYPE_SIZE(variable_to->info.datatype) * ccv_nnc_tensor_count(variable_to->info)"
, "ccv_nnc_dynamic_graph.c", 369, __extension__ __PRETTY_FUNCTION__
); }));
// Allowing vector type to be normal tensor, rather than a tensor view. We cannot have any offset though.
if (no_ofs && !stride_is_packed)
stride_is_packed = ccv_nnc_tensor_view_is_contiguous(tensor_variable->info.dim, tensor_variable->stride);
if (no_ofs && stride_is_packed)
tensor_variable->tensor_view = (ccv_nnc_tensor_view_t*)ccv_nnc_tensor_new(CCV_NNC_TENSOR_VIEW(variable_to->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(variable_to->tensor_view
) & ~(uintptr_t)1))->data.u8, tensor_variable->info, 0);
else {
if (no_stride)
	ccv_nnc_tensor_get_stride(tensor_variable->info.dim, tensor_variable->stride);
tensor_variable->tensor_view = ccv_nnc_tensor_view_new((ccv_nnc_tensor_t*)CCV_NNC_TENSOR_VIEW(variable_to->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(variable_to->tensor_view
) & ~(uintptr_t)1)), tensor_variable->info, tensor_variable->ofs, tensor_variable->stride);
}
if  (tensor_variable->alias_off)
ccv_nnc_tensor_data_add(tensor_variable->tensor_view->info, tensor_variable->alias_off, &tensor_variable->tensor_view->data, &tensor_variable->tensor_view->dataof);
return (ccv_nnc_tensor_t*)tensor_variable->tensor_view;
383}

385void ccv_nnc_tensor_variable_wait(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable)
386{
if (!tensor_variable || !tensor_variable->tensor_view)
return;
_ccv_nnc_tensor_variable_wait_fast_fence(tensor_variable->tensor_view);
390}

392static void _ccv_nnc_tensor_symbol_extra_new(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, const ccv_nnc_tensor_symbol_t symbol)
393{
if (symbol.d >= graph->binds->rnum)
{
const int rnum = graph->binds->rnum;
ccv_array_resize(graph->binds, symbol.d + 1);
int i;
for (i = rnum; i < graph->binds->rnum; i++)
	((ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, i)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(i))))->index = CCV_NNC_TENSOR_NO_VARIABLE;
}
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(symbol.d)));
bind->type = tensor_variable->type;
bind->index = tensor_variable->index;
if (tensor_variable->alias_index_ref)
{
const ccv_nnc_tensor_symbol_t alias_to = ccv_nnc_tensor_symbol_alias_to(graph->tape, (ccv_nnc_tensor_symbol_t){
	.d = symbol.d,
	.graph = graph->tape
});
assert(alias_to.d >= 0 && alias_to.d < graph->binds->rnum)((void) sizeof ((alias_to.d >= 0 && alias_to.d <
 graph->binds->rnum) ? 1 : 0), __extension__ ({ if (alias_to
.d >= 0 && alias_to.d < graph->binds->rnum
) ; else __assert_fail ("alias_to.d >= 0 && alias_to.d < graph->binds->rnum"
, "ccv_nnc_dynamic_graph.c", 411, __extension__ __PRETTY_FUNCTION__
); }));
bind->alias_ref = alias_to.d + 1;
} else
bind->alias_ref = 0;
if (bind->sources)
ccv_array_free(bind->sources);
bind->sources = 0;
if (bind->destinations)
ccv_array_free(bind->destinations);
bind->destinations = 0;
bind->destructor_hook.func = 0;
bind->destructor_hook.context = 0;
bind->tensor_view = 0;
424}

426static ccv_nnc_tensor_symbol_t _ccv_nnc_tensor_symbol_from_variable(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable)
427{
if (tensor_variable->symbol.d >= 0)
return tensor_variable->symbol;
if (!tensor_variable->alias_index_ref)
{
const ccv_nnc_tensor_symbol_t symbol = tensor_variable->symbol = ccv_nnc_tensor_symbol_new(graph->tape, tensor_variable->info, 0);
_ccv_nnc_tensor_symbol_extra_new(graph, tensor_variable, symbol);
return symbol;
}
const int alias_index = tensor_variable->alias_index_ref - 1;
assert(alias_index >= 0)((void) sizeof ((alias_index >= 0) ? 1 : 0), __extension__
 ({ if (alias_index >= 0) ; else __assert_fail ("alias_index >= 0"
, "ccv_nnc_dynamic_graph.c", 437, __extension__ __PRETTY_FUNCTION__
); }));
ccv_nnc_tensor_variable_t variable_to = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, alias_index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(alias_index)));
assert(!variable_to->alias_index_ref)((void) sizeof ((!variable_to->alias_index_ref) ? 1 : 0), __extension__
 ({ if (!variable_to->alias_index_ref) ; else __assert_fail
 ("!variable_to->alias_index_ref", "ccv_nnc_dynamic_graph.c"
, 439, __extension__ __PRETTY_FUNCTION__); }));
int no_stride = 1;
int i;
for (i = 0; no_stride && i < CCV_NNC_MAX_DIM_ALLOC(12); i++)
no_stride = (tensor_variable->stride[i] == 0);
if (no_stride)
ccv_nnc_tensor_get_stride(tensor_variable->info.dim, tensor_variable->stride);
const ccv_nnc_tensor_symbol_t symbol = tensor_variable->symbol = ccv_nnc_tensor_symbol_alias_new(graph->tape, _ccv_nnc_tensor_symbol_from_variable(graph, variable_to), tensor_variable->ofs, tensor_variable->stride, tensor_variable->info, 0);
_ccv_nnc_tensor_symbol_extra_new(graph, tensor_variable, symbol);
return symbol;
449}

451// Return the tensor variable that is old (the provided tensor variable will have a new setting).
452ccv_nnc_tensor_variable_t ccv_nnc_tensor_variable_exchange_new(ccv_nnc_dynamic_graph_t* const graph, ccv_nnc_tensor_variable_t tensor_variable)
453{
struct ccv_nnc_tensor_variable_s x = *tensor_variable;
ccv_nnc_tensor_variable_t new_variable;
// Need to handle alias.
if (x.alias_index_ref)
new_variable = ccv_nnc_tensor_variable_alias_new(graph, *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, x.alias_index_ref - 1)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(x.alias_index_ref - 1))), x.ofs, x.stride, x.info);
else
new_variable = ccv_nnc_tensor_variable_new(graph, x.info)ccv_nnc_tensor_variable_new_impl(graph, x.info);
*tensor_variable = *new_variable;
*new_variable = x;
// The index should be the same though.
const int index = new_variable->index;
new_variable->index = tensor_variable->index;
if (new_variable->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL)
{
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, new_variable->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(new_variable->symbol.d)));
bind->index = new_variable->index;
}
tensor_variable->index = index;
return new_variable;
473}

475void ccv_nnc_dynamic_graph_set_max_concurrency(ccv_nnc_dynamic_graph_t* const dynamic_graph, const int max_stream_count)
476{
dynamic_graph->max_stream_count = max_stream_count;
478}

480int ccv_nnc_dynamic_graph_set_no_grad(ccv_nnc_dynamic_graph_t* const dynamic_graph, const int no_grad)
481{
if (dynamic_graph->no_grad == no_grad)
return -1;
dynamic_graph->no_grad = no_grad;
return 0;
486}

488static ccv_nnc_stream_context_t* _ccv_nnc_dynamic_graph_get_stream(ccv_nnc_dynamic_graph_t* const graph, const int type)
489{
if (!graph->stream_map)
graph->stream_map = kh_init(stream_map)kh_init_stream_map();
int ret = 0;
khiter_t k = kh_put(stream_map, graph->stream_map, type, &ret)kh_put_stream_map(graph->stream_map, type, &ret);
assert(ret >= 0)((void) sizeof ((ret >= 0) ? 1 : 0), __extension__ ({ if (
ret >= 0) ; else __assert_fail ("ret >= 0", "ccv_nnc_dynamic_graph.c"
, 494, __extension__ __PRETTY_FUNCTION__); }));
ccv_nnc_stream_context_t* stream = kh_val(graph->stream_map, k)((graph->stream_map)->vals[k]);
// If ret == 0, the key already exist, we can return directly, otherwise, create and return.
if (ret != 0)
{
stream = ccv_nnc_stream_context_new(type);
kh_val(graph->stream_map, k)((graph->stream_map)->vals[k]) = stream;
}
return stream;
503}

505typedef struct {
ccv_nnc_dynamic_graph_t* graph;
int stream_type;
508} ccv_nnc_dynamic_graph_neighbor_context_discovery_t;

510static ccv_nnc_stream_context_t* _ccv_nnc_dynamic_graph_neighbor_context_discovery(const int device_id, void* const context)
511{
ccv_nnc_dynamic_graph_neighbor_context_discovery_t* const discovery = (ccv_nnc_dynamic_graph_neighbor_context_discovery_t*)context;
int type = discovery->stream_type;
CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
return _ccv_nnc_dynamic_graph_get_stream(discovery->graph, type);
516}

518static int _ccv_nnc_dynamic_graph_mark_gpu_to_cpu_transfer(const ccv_nnc_cmd_t cmd, ccv_nnc_tensor_variable_t* const output_variables, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context, ccv_nnc_tensor_t** const marked_tensors)
519{
520#ifdef HAVE_MPS
if (!stream_context || CCV_STREAM_GET_CONTEXT(stream_context->type)((stream_context->type) & 0x3) != CCV_STREAM_CONTEXT_GPU)
return 0;
if (cmd.cmd != CCV_NNC_DATA_TRANSFER_FORWARD && cmd.cmd != CCV_NNC_DATA_TRANSFER_BACKWARD)
return 0;
int marked_size = 0;
int i;
for (i = 0; i < ccv_min(input_size, output_size)({ typeof (input_size) _a = (input_size); typeof (output_size
) _b = (output_size); (_a < _b) ? _a : _b; }); i++)
{
ccv_nnc_tensor_variable_t const output_variable = output_variables[i];
ccv_nnc_tensor_view_t* const output_tensor_view = output_variable ? CCV_NNC_TENSOR_VIEW(output_variable->tensor_view)((ccv_nnc_tensor_view_t*)((uintptr_t)(output_variable->tensor_view
) & ~(uintptr_t)1)) : 0;
if (!inputs[i] || !outputs[i] || !output_variable || output_variable->alias_index_ref ||
	!output_tensor_view || CCV_IS_TENSOR_VIEW(output_tensor_view)((*(int*)(output_tensor_view)) & CCV_TENSOR_VIEW))
	continue;
if (CCV_TENSOR_GET_MEMORY(inputs[i]->info.type)((inputs[i]->info.type) & 0x3) != CCV_TENSOR_GPU_MEMORY ||
	CCV_TENSOR_GET_MEMORY(outputs[i]->info.type)((outputs[i]->info.type) & 0x3) != CCV_TENSOR_CPU_MEMORY)
	continue;
if (ccv_nnc_tensor_data_size_without_padding(outputs[i]->info) == 0)
	continue;
if (ccv_nnc_mps_tensor_fast_fence_mark_pending(outputs[i]))
	marked_tensors[marked_size++] = outputs[i];
}
return marked_size;
543#else
return 0;
545#endif
546}

548static void _ccv_nnc_dynamic_graph_clear_fast_fence_marks(ccv_nnc_tensor_t* const* const marked_tensors, const int marked_size)
549{
550#ifdef HAVE_MPS
int i;
for (i = 0; i < marked_size; i++)
ccv_nnc_mps_tensor_fast_fence_clear(marked_tensors[i]);
554#endif
555}

557void ccv_nnc_dynamic_graph_exec_ret(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, const ccv_nnc_tensor_variable_t* const inputs, const int input_size, ccv_nnc_tensor_variable_t* const outputs, const int output_size, const int parallel, ccv_nnc_stream_context_t* const stream_context, ccv_nnc_graph_exec_symbol_t* const graph_execs)
558{
int i, j;
for (i = 0; i < input_size; i++)
1
Assuming 'i' is >= 'input_size'→
2
←
Loop condition is false. Execution continues on line 563→
if (inputs[i] && !inputs[i]->alias_index_ref)
	{ assert(inputs[i]->tensor_view)((void) sizeof ((inputs[i]->tensor_view) ? 1 : 0), __extension__
 ({ if (inputs[i]->tensor_view) ; else __assert_fail ("inputs[i]->tensor_view"
, "ccv_nnc_dynamic_graph.c", 562, __extension__ __PRETTY_FUNCTION__
); })); }
ccv_nnc_tensor_t* input_tensors[ccv_max(1, input_size)({ typeof (1) _a = (1); typeof (input_size) _b = (input_size)
; (_a > _b) ? _a : _b; })];
3
←
'?' condition is true→
for (i = 0; i3.1
'i' is >= 'input_size'
 < input_size; i++)
4
←
Loop condition is false. Execution continues on line 566→
input_tensors[i] = inputs[i] ? ccv_nnc_tensor_from_variable(graph, inputs[i], stream_context)ccv_nnc_tensor_from_variable_impl(graph, inputs[i], stream_context
) : 0;
ccv_nnc_tensor_symbol_t input_symbols[ccv_max(1, input_size)({ typeof (1) _a = (1); typeof (input_size) _b = (input_size)
; (_a > _b) ? _a : _b; })];
5
←
'?' condition is true→
for (i = 0; i5.1
'i' is >= 'input_size'
 < input_size; i++)
6
←
Loop condition is false. Execution continues on line 569→
input_symbols[i] = inputs[i] ? _ccv_nnc_tensor_symbol_from_variable(graph, inputs[i]) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
ccv_array_t* input_sources[ccv_max(1, input_size)({ typeof (1) _a = (1); typeof (input_size) _b = (input_size)
; (_a > _b) ? _a : _b; })];
7
←
'?' condition is true→
ccv_array_t* input_alias_sources[ccv_max(1, input_size)({ typeof (1) _a = (1); typeof (input_size) _b = (input_size)
; (_a > _b) ? _a : _b; })];
8
←
'?' condition is true→
for (i = 0; i8.1
'i' is >= 'input_size'
 < input_size; i++)
9
←
Loop condition is false. Execution continues on line 583→
{
input_sources[i] = input_symbols[i].d != CCV_NNC_NO_TENSOR_SYMBOL ? ((ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, input_symbols[i].d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(input_symbols[i].d))))->sources : 0;
if (inputs[i] && inputs[i]->alias_index_ref)
{
	const int alias_index_ref = inputs[i]->alias_index_ref - 1;
	assert(alias_index_ref >= 0)((void) sizeof ((alias_index_ref >= 0) ? 1 : 0), __extension__
 ({ if (alias_index_ref >= 0) ; else __assert_fail ("alias_index_ref >= 0"
, "ccv_nnc_dynamic_graph.c", 577, __extension__ __PRETTY_FUNCTION__
); }));
	ccv_nnc_tensor_variable_t variable_to = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, alias_index_ref)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(alias_index_ref)));
	input_alias_sources[i] = ((ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, variable_to->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(variable_to->symbol.d))))->sources;
} else
	input_alias_sources[i] = 0;
}
const int parallel_count = ccv_max(1, parallel)({ typeof (1) _a = (1); typeof (parallel) _b = (parallel); (_a
 > _b) ? _a : _b; });
10
←
Assuming '_a' is <= '_b'→
11
←
'?' condition is false→
assert(input_size % parallel_count == 0)((void) sizeof ((input_size % parallel_count == 0) ? 1 : 0), __extension__
 ({ if (input_size % parallel_count == 0) ; else __assert_fail
 ("input_size % parallel_count == 0", "ccv_nnc_dynamic_graph.c"
, 584, __extension__ __PRETTY_FUNCTION__); }));
12
←
Assuming the condition is true→
13
←
Taking true branch→
const int per_input_size = input_size / parallel_count;
assert(output_size % parallel_count == 0)((void) sizeof ((output_size % parallel_count == 0) ? 1 : 0),
 __extension__ ({ if (output_size % parallel_count == 0) ; else
 __assert_fail ("output_size % parallel_count == 0", "ccv_nnc_dynamic_graph.c"
, 586, __extension__ __PRETTY_FUNCTION__); }));
14
←
Assuming the condition is true→
15
←
Taking true branch→
const int per_output_size = output_size / parallel_count;
int output_auto = 0;
for (i = 0; !output_auto15.1
'output_auto' is 0
 && i < output_size; i++)
16
←
Assuming 'i' is >= 'output_size'→
17
←
Loop condition is false. Execution continues on line 592→
output_auto = outputs[i] ? ccv_nnc_is_tensor_auto(outputs[i]->info) : 0;
// One extra step, infer the parameters for outputs.
if (output_auto17.1
'output_auto' is 0
)
18
←
Taking false branch→
{
ccv_nnc_tensor_param_t input_params[ccv_max(1, per_input_size)({ typeof (1) _a = (1); typeof (per_input_size) _b = (per_input_size
); (_a > _b) ? _a : _b; })];
ccv_nnc_tensor_param_t output_params[ccv_max(1, per_output_size)({ typeof (1) _a = (1); typeof (per_output_size) _b = (per_output_size
); (_a > _b) ? _a : _b; })];
for (i = 0; i < parallel_count; i++)
{
	for (j = 0; j < per_input_size; j++)
		input_params[j] = inputs[j + i * per_input_size] ? inputs[j + i * per_input_size]->info : ccv_nnc_tensor_auto;
	for (j = 0; j < per_output_size; j++)
		output_params[j] = outputs[j + i * per_output_size] ? outputs[j + i * per_output_size]->info : ccv_nnc_tensor_auto;
	ccv_nnc_hint_tensor_auto(cmd, input_params, per_input_size, hint, output_params, per_output_size);
	for (j = 0; j < per_output_size; j++)
		if (outputs[j + i * per_output_size])
			outputs[j + i * per_output_size]->info = output_params[j];
}
}
int freeable_size = 0;
ccv_nnc_tensor_variable_t freeables[ccv_max(1, output_size)({ typeof (1) _a = (1); typeof (output_size) _b = (output_size
); (_a > _b) ? _a : _b; })];
19
←
'?' condition is true→
// Refresh the symbol if it is binded to an existing exec. Otherwise we cannot keep the SSA guarantee.
for (i = 0; i19.1
'i' is >= 'output_size'
 < output_size; i++)
20
←
Loop condition is false. Execution continues on line 639→
{
// First, go over to see whether there is enforce inplace.
int enforce_idx = -1;
for (j = 0; enforce_idx < 0 && j < input_size; j++)
	if (inputs[j] && ccv_nnc_cmd_enforce_inplace(cmd, j, input_size, i, output_size))
		enforce_idx = j;
if (enforce_idx >= 0)
	{ assert(outputs[i] == inputs[enforce_idx] && outputs[i]->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL)((void) sizeof ((outputs[i] == inputs[enforce_idx] &&
 outputs[i]->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL) ? 1 : 0
), __extension__ ({ if (outputs[i] == inputs[enforce_idx] &&
 outputs[i]->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL) ; else __assert_fail
 ("outputs[i] == inputs[enforce_idx] && outputs[i]->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL"
, "ccv_nnc_dynamic_graph.c", 619, __extension__ __PRETTY_FUNCTION__
); })); }
// We don't allow or check "allow inplace" yet. That logic will be at odds with backward logic.
if (outputs[i] && outputs[i]->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL)
{
	const ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, outputs[i]->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(outputs[i]->symbol.d)));
	if (enforce_idx >= 0)
		{ assert(!bind->destinations || bind->destinations->rnum == 0)((void) sizeof ((!bind->destinations || bind->destinations
->rnum == 0) ? 1 : 0), __extension__ ({ if (!bind->destinations
 || bind->destinations->rnum == 0) ; else __assert_fail
 ("!bind->destinations || bind->destinations->rnum == 0"
, "ccv_nnc_dynamic_graph.c", 625, __extension__ __PRETTY_FUNCTION__
); })); }
	if (bind->sources && bind->sources->rnum > 0)
	{
		const ccv_nnc_tensor_variable_t old_var = freeables[freeable_size++] = ccv_nnc_tensor_variable_exchange_new(graph, outputs[i]);
		// If this is enforce output, make sure the tensor view is taken by the output.
		if (enforce_idx >= 0)
		{
			outputs[i]->destructor_hook = old_var->destructor_hook;
			outputs[i]->tensor_view = old_var->tensor_view; // Make sure the tensor view is taken over by the output.
			old_var->tensor_view = 0;
		}
	}
}
}
ccv_nnc_tensor_t* output_tensors[ccv_max(1, per_output_size)({ typeof (1) _a = (1); typeof (per_output_size) _b = (per_output_size
); (_a > _b) ? _a : _b; })];
21
←
Assuming '_a' is <= '_b'→
22
←
'?' condition is false→
if (parallel_count > 1)
23
←
Assuming 'parallel_count' is > 1→
24
←
Taking true branch→
{
const int max_device_id_size = per_input_size + per_output_size;
assert(max_device_id_size > 0)((void) sizeof ((max_device_id_size > 0) ? 1 : 0), __extension__
 ({ if (max_device_id_size > 0) ; else __assert_fail ("max_device_id_size > 0"
, "ccv_nnc_dynamic_graph.c", 643, __extension__ __PRETTY_FUNCTION__
); }));
25
←
Assuming 'max_device_id_size' is > 0→
26
←
Taking true branch→
int device_ids[max_device_id_size];
ccv_nnc_stream_context_t* streams[parallel_count];
ccv_nnc_stream_signal_t* signal;
if (stream_context)
27
←
Assuming 'stream_context' is null→
28
←
Taking false branch→
	signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
for (i = 0; i28.1
'i' is < 'parallel_count'
 < parallel_count; i++)
29
←
Loop condition is true.  Entering loop body→
{
	int flag = 0;
	for (j = 0; !flag29.1
'flag' is 0
 && j < per_input_size; j++)
30
←
Assuming 'j' is < 'per_input_size'→
31
←
Loop condition is true.  Entering loop body→
		if (input_tensors[i * per_input_size + j])
32
←
Branch condition evaluates to a garbage value
			flag = (CCV_TENSOR_GET_MEMORY(input_tensors[i * per_input_size + j]->info.type)((input_tensors[i * per_input_size + j]->info.type) & 0x3
) == CCV_TENSOR_GPU_MEMORY);
	for (j = 0; j < per_output_size; j++)
	{
		output_tensors[j] = outputs[j + i * per_output_size] ? ccv_nnc_tensor_from_variable(graph, outputs[j + i * per_output_size], stream_context)ccv_nnc_tensor_from_variable_impl(graph, outputs[j + i * per_output_size
], stream_context) : 0;
		if (output_tensors[j] && !flag)
			flag = (CCV_TENSOR_GET_MEMORY(output_tensors[j]->info.type)((output_tensors[j]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY);
	}
	const int stream_type = flag ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
	const int tensor_type = flag ? CCV_TENSOR_GPU_MEMORY : CCV_TENSOR_CPU_MEMORY;
	const int device_id_size = ccv_nnc_device_ids_for_io(input_tensors + i * per_input_size, per_input_size, output_tensors, per_output_size, tensor_type, device_ids, max_device_id_size);
	ccv_nnc_stream_context_t* stream_0 = 0;
	for (j = 0; j < device_id_size; j++)
	{
		int type = stream_type;
		CCV_STREAM_SET_DEVICE_ID(type, device_ids[j])(type) = (((type) & ~0xfff00) | (((device_ids[j]) & 0xfff
) << 8));
		ccv_nnc_stream_context_t* const stream = _ccv_nnc_dynamic_graph_get_stream(graph, type);
		if (!stream_0)
			stream_0 = stream;
	}
	// Wait signal to finish.
	if (stream_context)
	{
		if (stream_0)
			ccv_nnc_stream_context_wait_signal(stream_0, signal);
		else
			ccv_nnc_stream_context_wait(stream_context);
	}
	if (stream_0)
	{
		ccv_nnc_dynamic_graph_neighbor_context_discovery_t discovery = {
			.graph = graph,
			.stream_type = stream_type
		};
		ccv_nnc_stream_context_set_neighbor_discovery(stream_0, _ccv_nnc_dynamic_graph_neighbor_context_discovery, &discovery);
	}
	PRINT(CCV_CLI_INFO, "%s: [%d] -> [%d]\n", ccv_nnc_cmd_name(cmd.cmd), per_input_size, per_output_size)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("%s: [%d] -> [%d]\n", ccv_nnc_cmd_name(cmd.cmd), per_input_size
, per_output_size); fflush(stdout); } } while (0);
	int k;
	for (k = 0; k < per_input_size; k++)
	{
		PRINT(CCV_CLI_INFO, "|-> %d. %p (%p:%d)", k + 1, input_tensors[k + i * per_input_size], (input_tensors[k + i * per_input_size] ? input_tensors[k + i * per_input_size]->data.u8 : 0), (input_tensors[k + i * per_input_size] ? CCV_TENSOR_GET_DEVICE_ID(input_tensors[k + i * per_input_size]->info.type) : -1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("|-> %d. %p (%p:%d)", k + 1, input_tensors[k + i * per_input_size
], (input_tensors[k + i * per_input_size] ? input_tensors[k +
 i * per_input_size]->data.u8 : 0), (input_tensors[k + i *
 per_input_size] ? (((input_tensors[k + i * per_input_size]->
info.type) & 0xfff00) >> 8) : -1)); fflush(stdout);
 } } while (0);
		if (input_tensors[k + i * per_input_size] && CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_INFO)(CCV_CLI_INFO & ccv_cli_get_output_levels()))
			ccv_nnc_print_tensor_info(input_tensors[k + i * per_input_size]);
		PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("\n"); fflush(stdout); } } while (0);
	}
	for (k = 0; k < per_output_size; k++)
	{
		PRINT(CCV_CLI_INFO, "|<- %d. %p (%p:%d)", k + 1, output_tensors[k], (output_tensors[k] ? output_tensors[k]->data.u8 : 0), (output_tensors[k] ? CCV_TENSOR_GET_DEVICE_ID(output_tensors[k]->info.type) : -1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("|<- %d. %p (%p:%d)", k + 1, output_tensors[k], (output_tensors
[k] ? output_tensors[k]->data.u8 : 0), (output_tensors[k] ?
 (((output_tensors[k]->info.type) & 0xfff00) >> 8
) : -1)); fflush(stdout); } } while (0);
		if (output_tensors[k] && CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_INFO)(CCV_CLI_INFO & ccv_cli_get_output_levels()))
			ccv_nnc_print_tensor_shape(output_tensors[k]);
		PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("\n"); fflush(stdout); } } while (0);
	}
	ccv_nnc_tensor_t* marked_tensors[ccv_max(1, per_output_size)({ typeof (1) _a = (1); typeof (per_output_size) _b = (per_output_size
); (_a > _b) ? _a : _b; })];
	const int marked_size = _ccv_nnc_dynamic_graph_mark_gpu_to_cpu_transfer(cmd, outputs + i * per_output_size, input_tensors + i * per_input_size, per_input_size, output_tensors, per_output_size, stream_0, marked_tensors);
	const int status = ccv_nnc_cmd_exec(cmd, hint, flags, input_tensors + i * per_input_size, per_input_size, output_tensors, per_output_size, stream_0);
	if (status != 0)
		_ccv_nnc_dynamic_graph_clear_fast_fence_marks(marked_tensors, marked_size);
	if (status != 0)
		PRINT(CCV_CLI_INFO, "Invalid Status: %d\n", status)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("Invalid Status: %d\n", status); fflush(stdout); } } while (
0);
	if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
	{
		for (k = 0; k < per_output_size; k++)
		{
			PRINT(CCV_CLI_VERBOSE, "POST: |<- %d. %p (%p:%d)", k + 1, output_tensors[k], (output_tensors[k] ? output_tensors[k]->data.u8 : 0), (output_tensors[k] ? CCV_TENSOR_GET_DEVICE_ID(output_tensors[k]->info.type) : -1))do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
 { printf("POST: |<- %d. %p (%p:%d)", k + 1, output_tensors
[k], (output_tensors[k] ? output_tensors[k]->data.u8 : 0),
 (output_tensors[k] ? (((output_tensors[k]->info.type) &
 0xfff00) >> 8) : -1)); fflush(stdout); } } while (0);
			if (output_tensors[k])
				ccv_nnc_print_tensor_info(output_tensors[k]);
			PRINT(CCV_CLI_VERBOSE, "\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
 { printf("\n"); fflush(stdout); } } while (0);
		}
	}
	if (stream_context && stream_0)
	{
		ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
		ccv_nnc_stream_context_wait_signal(stream_context, signal);
	}
	streams[i] = stream_0;
}
if (!stream_context)
	for (i = 0; i < parallel_count; i++)
		if (streams[i])
			ccv_nnc_stream_context_wait(streams[i]);
} else {
for (i = 0; i < per_output_size; i++)
	output_tensors[i] = outputs[i] ? ccv_nnc_tensor_from_variable(graph, outputs[i], stream_context)ccv_nnc_tensor_from_variable_impl(graph, outputs[i], stream_context
) : 0;
PRINT(CCV_CLI_INFO, "%s: [%d] -> [%d]\n", ccv_nnc_cmd_name(cmd.cmd), per_input_size, per_output_size)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("%s: [%d] -> [%d]\n", ccv_nnc_cmd_name(cmd.cmd), per_input_size
, per_output_size); fflush(stdout); } } while (0);
for (i = 0; i < per_input_size; i++)
{
	PRINT(CCV_CLI_INFO, "|-> %d. %p (%p:%d)", i + 1, input_tensors[i], (input_tensors[i] ? input_tensors[i]->data.u8 : 0), (input_tensors[i] ? CCV_TENSOR_GET_DEVICE_ID(input_tensors[i]->info.type) : -1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("|-> %d. %p (%p:%d)", i + 1, input_tensors[i], (input_tensors
[i] ? input_tensors[i]->data.u8 : 0), (input_tensors[i] ? (
((input_tensors[i]->info.type) & 0xfff00) >> 8) :
 -1)); fflush(stdout); } } while (0);
	if (input_tensors[i] && CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_INFO)(CCV_CLI_INFO & ccv_cli_get_output_levels()))
		ccv_nnc_print_tensor_info(input_tensors[i]);
	PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("\n"); fflush(stdout); } } while (0);
}
ccv_nnc_tensor_t* marked_tensors[ccv_max(1, per_output_size)({ typeof (1) _a = (1); typeof (per_output_size) _b = (per_output_size
); (_a > _b) ? _a : _b; })];
const int marked_size = _ccv_nnc_dynamic_graph_mark_gpu_to_cpu_transfer(cmd, outputs, input_tensors, per_input_size, output_tensors, per_output_size, stream_context, marked_tensors);
const int status = ccv_nnc_cmd_exec(cmd, hint, flags, input_tensors, per_input_size, output_tensors, per_output_size, stream_context);
if (status != 0)
	_ccv_nnc_dynamic_graph_clear_fast_fence_marks(marked_tensors, marked_size);
for (i = 0; i < per_output_size; i++)
{
	PRINT(CCV_CLI_INFO, "|<- %d. %p (%p:%d)", i + 1, output_tensors[i], (output_tensors[i] ? output_tensors[i]->data.u8 : 0), (output_tensors[i] ? CCV_TENSOR_GET_DEVICE_ID(output_tensors[i]->info.type) : -1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("|<- %d. %p (%p:%d)", i + 1, output_tensors[i], (output_tensors
[i] ? output_tensors[i]->data.u8 : 0), (output_tensors[i] ?
 (((output_tensors[i]->info.type) & 0xfff00) >> 8
) : -1)); fflush(stdout); } } while (0);
	if (output_tensors[i] && CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_INFO)(CCV_CLI_INFO & ccv_cli_get_output_levels()))
		ccv_nnc_print_tensor_info(output_tensors[i]);
	PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf
("\n"); fflush(stdout); } } while (0);
}
}
int inputs_are_constants = 1;
for (i = 0; inputs_are_constants && i < input_size; i++)
if (inputs[i] && inputs[i]->type != CCV_NNC_TENSOR_CONSTANT)
	inputs_are_constants = 0;
if (input_size > 0 && !inputs_are_constants && !graph->no_grad) // No need to record the execution if there is no input or we disabled gradient computation.
{
ccv_nnc_tensor_symbol_t output_symbols[ccv_max(1, output_size)({ typeof (1) _a = (1); typeof (output_size) _b = (output_size
); (_a > _b) ? _a : _b; })];
for (i = 0; i < output_size; i++)
	if (outputs[i])
	{
		assert(outputs[i]->type != CCV_NNC_TENSOR_CONSTANT)((void) sizeof ((outputs[i]->type != CCV_NNC_TENSOR_CONSTANT
) ? 1 : 0), __extension__ ({ if (outputs[i]->type != CCV_NNC_TENSOR_CONSTANT
) ; else __assert_fail ("outputs[i]->type != CCV_NNC_TENSOR_CONSTANT"
, "ccv_nnc_dynamic_graph.c", 767, __extension__ __PRETTY_FUNCTION__
); }));
		output_symbols[i] = _ccv_nnc_tensor_symbol_from_variable(graph, outputs[i]);
	} else
		output_symbols[i] = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
int t;
for (t = 0; t < parallel_count; t++)
{
	ccv_nnc_graph_exec_symbol_t graph_exec = ccv_nnc_graph_exec_symbol_new(graph->tape, cmd, input_symbols + t * per_input_size, per_input_size, output_symbols + t * per_output_size, per_output_size, 0);
	if (graph_execs)
		graph_execs[t] = graph_exec;
	// This needs to be done before we set the new sources on the outputs.
	for (i = 0; i < per_input_size; i++)
	{
		ccv_array_t* const input_source = input_sources[i + t * per_input_size];
		if (input_source)
			for (j = 0; j < input_source->rnum; j++)
				ccv_nnc_graph_exec_symbol_concat(graph->tape, (ccv_nnc_graph_exec_symbol_t){
					.d = *(int*)ccv_array_get(input_source, j)((void*)(((char*)((input_source)->data)) + (size_t)(input_source
)->rsize * (size_t)(j))),
					.graph = graph->tape
				}, graph_exec);
		ccv_array_t* const input_alias_source = input_alias_sources[i + t * per_input_size];
		if (input_alias_source)
			for (j = 0; j < input_alias_source->rnum; j++)
				ccv_nnc_graph_exec_symbol_concat(graph->tape, (ccv_nnc_graph_exec_symbol_t){
					.d = *(int*)ccv_array_get(input_alias_source, j)((void*)(((char*)((input_alias_source)->data)) + (size_t)(
input_alias_source)->rsize * (size_t)(j))),
					.graph = graph->tape
				}, graph_exec);
	}
	for (i = 0; i < per_input_size; i++)
	{
		ccv_nnc_tensor_variable_t const input = inputs[i + t * per_input_size];
		if (!input || input_symbols[i + t * per_input_size].d == CCV_NNC_NO_TENSOR_SYMBOL)
			continue;
		// Constant inputs still need lifetime tracking while this exec is alive because
		// backward may read their concrete tensor buffers even though they do not require
		// gradients themselves.
		ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, input_symbols[i + t * per_input_size].d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(input_symbols[i + t * per_input_size
].d)));
		if (!bind->destinations)
			bind->destinations = ccv_array_new(sizeof(int), 1, 0);
		ccv_array_add_unique_int(bind->destinations, graph_exec.d);
		if (input->alias_index_ref)
		{
				const int alias_index = input->alias_index_ref - 1;
				assert(alias_index >= 0)((void) sizeof ((alias_index >= 0) ? 1 : 0), __extension__
 ({ if (alias_index >= 0) ; else __assert_fail ("alias_index >= 0"
, "ccv_nnc_dynamic_graph.c", 810, __extension__ __PRETTY_FUNCTION__
); }));
				ccv_nnc_tensor_variable_t variable_to = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, alias_index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(alias_index)));
				ccv_nnc_tensor_variable_graph_bind_t* const root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, variable_to->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(variable_to->symbol.d)));
				if (!root_bind->destinations)
					root_bind->destinations = ccv_array_new(sizeof(int), 1, 0);
				ccv_array_add_unique_int(root_bind->destinations, graph_exec.d);
		}
	}
	for (i = 0; i < per_output_size; i++)
	{
		ccv_nnc_tensor_variable_t const output = outputs[i + t * per_output_size];
		if (!output)
			continue;
		ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, output_symbols[i + t * per_output_size].d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(output_symbols[i + t * per_output_size
].d)));
		assert(!bind->sources)((void) sizeof ((!bind->sources) ? 1 : 0), __extension__ (
{ if (!bind->sources) ; else __assert_fail ("!bind->sources"
, "ccv_nnc_dynamic_graph.c", 824, __extension__ __PRETTY_FUNCTION__
); })); // This is a new symbol, therefore, no binded sources associated yet.
		bind->sources = ccv_array_new(sizeof(int), 1, 0);
		ccv_array_add_unique_int(bind->sources, graph_exec.d);
		if (output->alias_index_ref)
		{
			const int alias_index = output->alias_index_ref - 1;
			assert(alias_index >= 0)((void) sizeof ((alias_index >= 0) ? 1 : 0), __extension__
 ({ if (alias_index >= 0) ; else __assert_fail ("alias_index >= 0"
, "ccv_nnc_dynamic_graph.c", 830, __extension__ __PRETTY_FUNCTION__
); }));
			ccv_nnc_tensor_variable_t variable_to = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, alias_index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(alias_index)));
			ccv_nnc_tensor_variable_graph_bind_t* const root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, variable_to->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(variable_to->symbol.d)));
			if (!root_bind->sources)
				root_bind->sources = ccv_array_new(sizeof(int), 1, 0);
			ccv_array_add_unique_int(root_bind->sources, graph_exec.d);
		}
	}
}
}
// Now, able to free some of the reused outputs.
for (i = 0; i < freeable_size; i++)
ccv_nnc_tensor_variable_free(graph, freeables[i]);
843}

845int ccv_nnc_dynamic_graph_exec(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, const ccv_nnc_tensor_variable_t* const inputs, const int input_size, ccv_nnc_tensor_variable_t* const outputs, const int output_size, const int parallel, ccv_nnc_stream_context_t* const stream_context)
846{
ccv_nnc_dynamic_graph_exec_ret(graph, cmd, hint, flags, inputs, input_size, outputs, output_size, parallel, stream_context, 0);
return CCV_NNC_EXEC_SUCCESS;
849}

851static int _ccv_nnc_tensor_variable_is_only_output(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_graph_bind_t* bind, const int symbol_d)
852{
if (bind->alias_ref)
bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, bind->alias_ref - 1)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(bind->alias_ref - 1)));
if (!bind->sources || bind->sources->rnum == 0)
return 1;
int i;
for (i = 0; i < bind->sources->rnum; i++)
{
const int exec_symbol_d = *(int*)ccv_array_get(bind->sources, i)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(i)));
const ccv_nnc_graph_exec_symbol_t exec_symbol = {
	.d = exec_symbol_d,
	.graph = graph->tape
};
const int* outputs; int output_size;
ccv_nnc_graph_exec_symbol_io(graph->tape, exec_symbol, 0, 0, &outputs, &output_size);
int j;
for (j = 0; j < output_size; j++)
	if (outputs[j] >= 0 && outputs[j] != symbol_d) // If output is me, it is the only output.
	{
		assert(outputs[j] < graph->binds->rnum)((void) sizeof ((outputs[j] < graph->binds->rnum) ? 1
 : 0), __extension__ ({ if (outputs[j] < graph->binds->
rnum) ; else __assert_fail ("outputs[j] < graph->binds->rnum"
, "ccv_nnc_dynamic_graph.c", 871, __extension__ __PRETTY_FUNCTION__
); }));
		const ccv_nnc_tensor_variable_graph_bind_t* other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, outputs[j])((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(outputs[j])));
		// This is in use and is it not a constant symbol.
		if (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT)
			return 0;
		if (other_bind->alias_ref) // If this is alias, use its original's destinations.
			other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, other_bind->alias_ref - 1)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(other_bind->alias_ref - 1
)));
		// The original is in use and is it not a constant symbol.
		if (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT)
			return 0;
		if (other_bind->destinations && other_bind->destinations->rnum > 0)
			return 0;
	}
}
return 1;
886}

888static void _ccv_nnc_update_bind_destinations_when_free(ccv_nnc_dynamic_graph_t* const graph, const int freed_exec_symbol_d, ccv_array_t* const binds, ccv_nnc_tensor_variable_graph_bind_t* const bind, const int tensor_index, ccv_array_t* const ws)
889{
int i;
if (bind->destinations)
{
int flag = 0;
for (i = 0; !flag && i < bind->destinations->rnum; i++)
{
	const int exec_symbol_d = *(int*)ccv_array_get(bind->destinations, i)((void*)(((char*)((bind->destinations)->data)) + (size_t
)(bind->destinations)->rsize * (size_t)(i)));
	if (exec_symbol_d == freed_exec_symbol_d)
	{
		if (i < bind->destinations->rnum - 1)
			*(int*)ccv_array_get(bind->destinations, i)((void*)(((char*)((bind->destinations)->data)) + (size_t
)(bind->destinations)->rsize * (size_t)(i))) = *(int*)ccv_array_get(bind->destinations, bind->destinations->rnum - 1)((void*)(((char*)((bind->destinations)->data)) + (size_t
)(bind->destinations)->rsize * (size_t)(bind->destinations
->rnum - 1)));
		--bind->destinations->rnum;
		flag = 1;
	}
}
// This symbol can be freed.
if (flag && bind->index == CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED)
{
	ccv_nnc_tensor_variable_graph_bind_t* root_bind = bind;
	if (bind->alias_ref)
	{
		root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(binds, bind->alias_ref - 1)((void*)(((char*)((binds)->data)) + (size_t)(binds)->rsize
 * (size_t)(bind->alias_ref - 1)));
		if (root_bind->index == CCV_NNC_TENSOR_NO_VARIABLE)
			root_bind = bind;
	}
	// If the alias_ref is not freed, we cannot free this, unless it is very clear there is no reference to this any more.
	// It is possible because exec will be freed already, thus, it is safe to remove this alias out.
	if (root_bind->index == CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED &&
		((!root_bind->sources || root_bind->sources->rnum == 0) || _ccv_nnc_tensor_variable_is_only_output(graph, bind, tensor_index)) &&
		root_bind->destinations->rnum == 0)
	{
		if (root_bind->sources)
			for (i = 0; i < root_bind->sources->rnum; i++)
				ccv_array_add_unique_int(ws, *(int*)ccv_array_get(root_bind->sources, i)((void*)(((char*)((root_bind->sources)->data)) + (size_t
)(root_bind->sources)->rsize * (size_t)(i))));
		_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
		ccv_nnc_tensor_symbol_free(graph->tape, (ccv_nnc_tensor_symbol_t){
			.d = tensor_index,
			.graph = graph->tape
		});
	} else if (bind->index == CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED && // Handle the case the bind is already freed, and it doesn't have any sources or destinations.
		bind->alias_ref && (!bind->sources || bind->sources->rnum == 0) && (!bind->destinations || bind->destinations->rnum == 0)) {
		_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
		ccv_nnc_tensor_symbol_free(graph->tape, (ccv_nnc_tensor_symbol_t){
			.d = tensor_index,
			.graph = graph->tape
		});
	}
}
}
939}

941static void _ccv_nnc_update_bind_sources_when_free(ccv_nnc_dynamic_graph_t* const graph, const int freed_exec_symbol_d, ccv_array_t* const binds, ccv_nnc_tensor_variable_graph_bind_t* const bind, const int tensor_index, ccv_array_t* const ws)
942{
int i;
if (bind->sources)
{
int flag = 0;
for (i = 0; !flag && i < bind->sources->rnum; i++)
{
	const int exec_symbol_d = *(int*)ccv_array_get(bind->sources, i)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(i)));
	if (exec_symbol_d == freed_exec_symbol_d)
	{
		if (i < bind->sources->rnum - 1)
			*(int*)ccv_array_get(bind->sources, i)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(i))) = *(int*)ccv_array_get(bind->sources, bind->sources->rnum - 1)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(bind->sources->rnum -
 1)));
		--bind->sources->rnum;
		flag = 1;
	}
}
if (flag && !bind->alias_ref && bind->index >= 0 && bind->type == CCV_NNC_TENSOR_CONSTANT && // If it is detached (constant but previously has sources). Now can check again.
	(bind->sources->rnum == 0 || _ccv_nnc_tensor_variable_is_only_output(graph, bind, tensor_index)) &&
	(!bind->destinations || bind->destinations->rnum == 0))
{
	// If this is constant, set it to be no symbol again.
	ccv_nnc_tensor_variable_t tv = *(ccv_nnc_tensor_variable_t*)ccv_array_get(graph->vars, bind->index)((void*)(((char*)((graph->vars)->data)) + (size_t)(graph
->vars)->rsize * (size_t)(bind->index)));
	tv->symbol = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
	_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
	ccv_nnc_tensor_symbol_free(graph->tape, (ccv_nnc_tensor_symbol_t){
		.d = tensor_index,
		.graph = graph->tape
	});
} else if (flag && bind->index == CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED) {
	// This symbol can be freed.
	ccv_nnc_tensor_variable_graph_bind_t* root_bind = bind;
	if (bind->alias_ref)
	{
		root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(binds, bind->alias_ref - 1)((void*)(((char*)((binds)->data)) + (size_t)(binds)->rsize
 * (size_t)(bind->alias_ref - 1)));
		if (root_bind->index == CCV_NNC_TENSOR_NO_VARIABLE)
			root_bind = bind;
	}
	// If the alias_ref is not freed, we cannot free this, unless it is very clear there is no reference to this any more.
	// It is possible because exec will be freed already, thus, it is safe to remove this alias out.
	if (root_bind->index == CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED &&
		(root_bind->sources->rnum == 0 || _ccv_nnc_tensor_variable_is_only_output(graph, bind, tensor_index)) &&
		(!root_bind->destinations || root_bind->destinations->rnum == 0))
	{
		for (i = 0; i < root_bind->sources->rnum; i++)
			ccv_array_add_unique_int(ws, *(int*)ccv_array_get(root_bind->sources, i)((void*)(((char*)((root_bind->sources)->data)) + (size_t
)(root_bind->sources)->rsize * (size_t)(i))));
		_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
		ccv_nnc_tensor_symbol_free(graph->tape, (ccv_nnc_tensor_symbol_t){
			.d = tensor_index,
			.graph = graph->tape
		});
	} else if (bind->index == CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED && // Handle the case the bind is already freed, and it doesn't have any sources or destinations.
		bind->alias_ref && (!bind->sources || bind->sources->rnum == 0) && (!bind->destinations || bind->destinations->rnum == 0)) {
		_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
		ccv_nnc_tensor_symbol_free(graph->tape, (ccv_nnc_tensor_symbol_t){
			.d = tensor_index,
			.graph = graph->tape
		});
	}
}
}
1002}

1004static void _ccv_nnc_update_bind_sources_destinations_when_free(ccv_nnc_dynamic_graph_t* const graph, const int freed_exec_symbol_d, ccv_array_t* const binds, const int* const inputs, const int input_size, const int* const outputs, const int output_size, ccv_array_t* const ws)
1005{
int i;
for (i = 0; i < input_size; i++)
if (inputs[i] >= 0 && inputs[i] < binds->rnum)
{
	ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(binds, inputs[i])((void*)(((char*)((binds)->data)) + (size_t)(binds)->rsize
 * (size_t)(inputs[i])));
	if (bind->index == CCV_NNC_TENSOR_NO_VARIABLE)
		continue;
	if (bind->alias_ref)
	{
		const int alias_to = bind->alias_ref - 1;
		ccv_nnc_tensor_variable_graph_bind_t* const root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(binds, alias_to)((void*)(((char*)((binds)->data)) + (size_t)(binds)->rsize
 * (size_t)(alias_to)));
		if (root_bind && root_bind->index != CCV_NNC_TENSOR_NO_VARIABLE)
			_ccv_nnc_update_bind_destinations_when_free(graph, freed_exec_symbol_d, binds, root_bind, alias_to, ws);
	}
	_ccv_nnc_update_bind_destinations_when_free(graph, freed_exec_symbol_d, binds, bind, inputs[i], ws);
}
// Note that this works because there is no overlap of inputs / outputs. (What about alias?).
for (i = 0; i < output_size; i++)
if (outputs[i] >= 0 && outputs[i] < binds->rnum)
{
	ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(binds, outputs[i])((void*)(((char*)((binds)->data)) + (size_t)(binds)->rsize
 * (size_t)(outputs[i])));
	if (bind->index == CCV_NNC_TENSOR_NO_VARIABLE)
		continue;
	if (bind->alias_ref)
	{
		const int alias_to = bind->alias_ref - 1;
		ccv_nnc_tensor_variable_graph_bind_t* const root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(binds, alias_to)((void*)(((char*)((binds)->data)) + (size_t)(binds)->rsize
 * (size_t)(alias_to)));
		if (root_bind && root_bind->index != CCV_NNC_TENSOR_NO_VARIABLE)
			_ccv_nnc_update_bind_sources_when_free(graph, freed_exec_symbol_d, binds, root_bind, alias_to, ws);
	}
	_ccv_nnc_update_bind_sources_when_free(graph, freed_exec_symbol_d, binds, bind, outputs[i], ws);
}
1038}

1040static void _ccv_nnc_stateful_exec_free_if_possible(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_graph_exec_symbol_t symbol)
1041{
if (!graph->stateful_execs)
return;
assert(symbol.d >= 0)((void) sizeof ((symbol.d >= 0) ? 1 : 0), __extension__ ({
 if (symbol.d >= 0) ; else __assert_fail ("symbol.d >= 0"
, "ccv_nnc_dynamic_graph.c", 1044, __extension__ __PRETTY_FUNCTION__
); }));
ccv_array_t* const stateful_execs = graph->stateful_execs;
ccv_nnc_cmd_t cmd = ccv_nnc_graph_exec_symbol_cmd(graph->tape, symbol);
ccv_nnc_stateful_exec_t* const stateful_exec = (ccv_nnc_stateful_exec_t*)cmd.data;
if (!stateful_exec)
return;
// If there is no backward, no need to apply gradients.
// Otherwise, if we applied gradients, we can free it as well.
// We don't free this stateful exec because apply gradients doesn't require any variables alive.
if (!stateful_exec->did_backward_but_not_apply_gradients)
{
const int index = stateful_exec->index;
ccfreefree(stateful_exec);
if (index < graph->reuse_stateful_exec || graph->reuse_stateful_exec < 0)
	graph->reuse_stateful_exec = index;
*(ccv_nnc_stateful_exec_t**)ccv_array_get(stateful_execs, index)((void*)(((char*)((stateful_execs)->data)) + (size_t)(stateful_execs
)->rsize * (size_t)(index))) = 0;
} else
stateful_exec->should_free = 1;
1062}

1064static int _ccv_nnc_tensor_bind_trace_forward_to_free(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable, ccv_nnc_tensor_variable_graph_bind_t* const bind, ccv_nnc_tensor_variable_graph_bind_t* const root_bind, int* const ws_start, const int assuming_no_source) // assuming_no_source means we are going to remove sources if possible, thus, it is irrelevant.
1065{
int can_free_symbol = 0;
const int sources_and_is_only_output = (root_bind->sources && root_bind->sources->rnum > 0) && _ccv_nnc_tensor_variable_is_only_output(graph, bind, tensor_variable->symbol.d);
if (!root_bind->sources || root_bind->sources->rnum == 0 || sources_and_is_only_output || assuming_no_source)
{
int i, j;
can_free_symbol = 1; // Assume we can free this symbol.
if (!graph->ws)
	graph->ws = ccv_array_new(sizeof(int), root_bind->destinations ? root_bind->destinations->rnum : 0, 0);
ccv_array_t* const ws = graph->ws;
ccv_array_clear(ws);
if (root_bind->destinations)
	for (i = 0; i < root_bind->destinations->rnum; i++)
		ccv_array_add_unique_int(ws, *(int*)ccv_array_get(root_bind->destinations, i)((void*)(((char*)((root_bind->destinations)->data)) + (
size_t)(root_bind->destinations)->rsize * (size_t)(i))));
const int ws_init_size = ws->rnum;
*ws_start = ws_init_size;
// Add all sources from root_bind, in case it has been freed (during update bind sources / destinations when free.
if (root_bind->sources)
	for (i = 0; i < root_bind->sources->rnum; i++)
		ccv_array_add_unique_int(ws, *(int*)ccv_array_get(root_bind->sources, i)((void*)(((char*)((root_bind->sources)->data)) + (size_t
)(root_bind->sources)->rsize * (size_t)(i))));
// If we cannot loop over any exec symbols (this is not in use). It is simple to determine whether we want
// to free it or not: if this is an alias and the origin is not freed, we cannot free this symbol.
if (ws_init_size == 0)
	can_free_symbol = (!bind->alias_ref || root_bind->index < 0);
// Go through all the exec symbols use this tensor, to see whether they have inputs that has other sources.
for (i = 0; i < ws_init_size; i++)
{
	const int exec_symbol_d = *(int*)ccv_array_get(ws, i)((void*)(((char*)((ws)->data)) + (size_t)(ws)->rsize * (
size_t)(i)));
	const ccv_nnc_graph_exec_symbol_t symbol = {
		.d = exec_symbol_d,
		.graph = graph->tape
	};
	const int* inputs; int input_size;
	const int* outputs; int output_size;
	ccv_nnc_graph_exec_symbol_io(graph->tape, symbol, &inputs, &input_size, &outputs, &output_size);
	int flag = 0; // flag denotes whether there are cases to keep this exec symbol.
	if (!root_bind->sources || root_bind->sources->rnum == 0 || assuming_no_source)
	{
		// If there is no sources, check if other sources can depend on this exec, if they do, we cannot free this.
		for (j = 0; !flag && j < input_size; j++)
			if (inputs[j] >= 0 && inputs[j] < graph->binds->rnum && inputs[j] != tensor_variable->symbol.d)
			{
				ccv_nnc_tensor_variable_graph_bind_t* other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, inputs[j])((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(inputs[j])));
				if (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT)
					flag = 1;
				else {
					if (other_bind->alias_ref) // If this is alias, use its original's destinations.
						other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, other_bind->alias_ref - 1)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(other_bind->alias_ref - 1
)));
					flag = (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT) || (other_bind->type != CCV_NNC_TENSOR_CONSTANT && other_bind->sources && other_bind->sources->rnum > 0); // Constant should have no source, or it is detached.
				}
			}
	} else {
		// If there are sources, check whether we have outputs or not. If we do, we cannot free this.
		for (j = 0; !flag && j < output_size; j++)
			if (outputs[j] >= 0 && outputs[j] < graph->binds->rnum)
			{
				ccv_nnc_tensor_variable_graph_bind_t* other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, outputs[j])((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(outputs[j])));
				if (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT)
					flag = 1;
				else {
					if (other_bind->alias_ref) // If this is alias, use its original's destinations.
						other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, other_bind->alias_ref - 1)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(other_bind->alias_ref - 1
)));
					flag = (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT) || (other_bind->destinations && other_bind->destinations->rnum > 0);
				}
			}
	}
	// This exec can be freed if there is no input required or there is no output required.
	can_free_symbol = (can_free_symbol && !flag);
	if (!flag)
	{
		// Go over inputs and remove all references from binded destinations.
		// and go over outputs remove all references from binded sources.
		_ccv_nnc_update_bind_sources_destinations_when_free(graph, exec_symbol_d, graph->binds, inputs, input_size, outputs, output_size, ws);
		const int* outgoings; int outgoing_size;
		ccv_nnc_graph_exec_symbol_to(graph->tape, symbol, &outgoings, &outgoing_size);
		for (j = 0; j < outgoing_size; j++)
			ccv_array_add_unique_int(ws, outgoings[j]);
		_ccv_nnc_stateful_exec_free_if_possible(graph, symbol);
		ccv_nnc_graph_exec_symbol_free(graph->tape, symbol);
	}
}
}
return can_free_symbol;
1148}

1150static void _ccv_nnc_tensor_bind_trace_backward_to_free(ccv_nnc_dynamic_graph_t* const graph, ccv_array_t* const ws, const int ws_start)
1151{
int i, j;
// Now, go over the outgoings, if it is removed, add more to it. Note that the ws array can grow while iterating over.
for (i = ws_start; i < ws->rnum; i++)
{
const int exec_symbol_d = *(int*)ccv_array_get(ws, i)((void*)(((char*)((ws)->data)) + (size_t)(ws)->rsize * (
size_t)(i)));
const ccv_nnc_graph_exec_symbol_t symbol = {
	.d = exec_symbol_d,
	.graph = graph->tape
};
const int* inputs; int input_size;
const int* outputs; int output_size;
ccv_nnc_graph_exec_symbol_io(graph->tape, symbol, &inputs, &input_size, &outputs, &output_size);
int flag = 0;
for (j = 0; !flag && j < input_size; j++)
	if (inputs[j] >= 0 && inputs[j] < graph->binds->rnum)
	{
		ccv_nnc_tensor_variable_graph_bind_t* other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, inputs[j])((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(inputs[j])));
		if (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT)
			flag = 1;
		else {
			if (other_bind->alias_ref) // If this is alias, use its original's destinations.
				other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, other_bind->alias_ref - 1)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(other_bind->alias_ref - 1
)));
			flag = (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT) || (other_bind->type != CCV_NNC_TENSOR_CONSTANT && other_bind->sources && other_bind->sources->rnum > 0);
		}
	}
if (flag) // If any inputs make free this destination impossible. Check whether all its outputs are done.
{
	int output_flag = 0;
	for (j = 0; !output_flag && j < output_size; j++)
		if (outputs[j] >= 0 && outputs[j] < graph->binds->rnum)
		{
			ccv_nnc_tensor_variable_graph_bind_t* other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, outputs[j])((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(outputs[j])));
			if (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT)
				output_flag = 1;
			else {
				if (other_bind->alias_ref) // If this is alias, use its original's destinations.
					other_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, other_bind->alias_ref - 1)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(other_bind->alias_ref - 1
)));
				output_flag = (other_bind->index >= 0 && other_bind->type != CCV_NNC_TENSOR_CONSTANT) || (other_bind->destinations && other_bind->destinations->rnum > 0);
			}
		}
	if (!output_flag) // If no output is used (used means it has a tensor variable, or it has a destination).
		flag = 0;
}
// Went over all the inputs, it turns out no more inputs has other references, safe to remove.
if (!flag)
{
	_ccv_nnc_update_bind_sources_destinations_when_free(graph, exec_symbol_d, graph->binds, inputs, input_size, outputs, output_size, ws);
	const int* outgoings; int outgoing_size;
	ccv_nnc_graph_exec_symbol_to(graph->tape, symbol, &outgoings, &outgoing_size);
	// It it has outgoings, add that for further inspection.
	for (j = 0; j < outgoing_size; j++)
		ccv_array_add_unique_int(ws, outgoings[j]);
	_ccv_nnc_stateful_exec_free_if_possible(graph, symbol);
	ccv_nnc_graph_exec_symbol_free(graph->tape, symbol);
}
}
1208}

1210void ccv_nnc_tensor_variable_free(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable)
1211{
// If it contains a symbol, this tensor variable is not a free variable. It is either used as input or output.
if (tensor_variable->symbol.d != CCV_NNC_NO_TENSOR_SYMBOL)
{
// If it is not a free variable, when can we free the symbol and the underlying variable?
// 1. There should be no sources (the command generate this tensor should be freed) or the output of these sources is only the current one;
// 2. The destinations (the commands that uses this tensor) should have no other inputs, or the other inputs has no binded sources as well.
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, tensor_variable->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(tensor_variable->symbol.d
)));
// There should be no source associated with it no more.
// I am free if no exec symbol is producing me or the symbol producing me can only producing me (thus, it is not required to
// compute gradient because I am the only variable it can compute gradient for).
ccv_nnc_tensor_variable_graph_bind_t* root_bind = bind;
if (bind->alias_ref)
{
	const int alias_to = bind->alias_ref - 1;
	root_bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, alias_to)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(alias_to)));
}
int ws_start;
const int can_free_symbol = _ccv_nnc_tensor_bind_trace_forward_to_free(graph, tensor_variable, bind, root_bind, &ws_start, 0);
if (can_free_symbol)
{
	_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
	ccv_nnc_tensor_symbol_free(graph->tape, tensor_variable->symbol);
	_ccv_nnc_tensor_bind_trace_backward_to_free(graph, graph->ws, ws_start);
} else { // If this symbol is not freed, move the tensor view to the bind.
	// If current bind is an alias, and it doesn't have any sources or destinations. We cannot find this alias
	// through any exec. This is not only safe to delete, but has to be deleted. We don't need to handle this
	// if free_symbol is true, because when that happens, root_bind will be deleted, and we will clean up the
	// alias in that process.
	if (bind->alias_ref && (!bind->sources || bind->sources->rnum == 0) && (!bind->destinations || bind->destinations->rnum == 0))
	{
		_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
		ccv_nnc_tensor_symbol_free(graph->tape, tensor_variable->symbol);
	} else {
		bind->index = CCV_NNC_TENSOR_NO_VARIABLE_BUT_USED; // This tensor variable will be freed, but this symbol extra will continue exists.
		bind->destructor_hook.func = tensor_variable->destructor_hook.func; // Transfer the destructor callback.
		bind->destructor_hook.context = tensor_variable->destructor_hook.context; // Transfer the destructor callback context.
		bind->tensor_view = tensor_variable->tensor_view; // Transfer the ownership to the bind.
		tensor_variable->tensor_view = 0;
	}
}
}
_ccv_nnc_tensor_variable_free(graph, tensor_variable, 1);
1254}

1256void ccv_nnc_tensor_variable_detach(ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t tensor_variable)
1257{
// This cannot be an alias.
assert(!tensor_variable->alias_index_ref)((void) sizeof ((!tensor_variable->alias_index_ref) ? 1 : 0
), __extension__ ({ if (!tensor_variable->alias_index_ref)
 ; else __assert_fail ("!tensor_variable->alias_index_ref"
, "ccv_nnc_dynamic_graph.c", 1259, __extension__ __PRETTY_FUNCTION__
); }));
// If no computation done yet, mark this as constant.
if (tensor_variable->symbol.d == CCV_NNC_NO_TENSOR_SYMBOL)
{
tensor_variable->type = CCV_NNC_TENSOR_CONSTANT;
return;
}
// Otherwise, we need to do some book keeping updates to make sure it doesn't participate gradient computation any more.
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, tensor_variable->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(tensor_variable->symbol.d
)));
// Because tensor variable cannot be alias, its bind cannot have alias pointer.
assert(!bind->alias_ref)((void) sizeof ((!bind->alias_ref) ? 1 : 0), __extension__
 ({ if (!bind->alias_ref) ; else __assert_fail ("!bind->alias_ref"
, "ccv_nnc_dynamic_graph.c", 1269, __extension__ __PRETTY_FUNCTION__
); }));
// Go through to break ties between sources and destinations.
int i, j;
if (bind->sources && bind->destinations)
{
for (i = 0; i < bind->sources->rnum; i++)
{
	const int s = *(int*)ccv_array_get(bind->sources, i)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(i)));
	const int* outputs; int output_size;
	const ccv_nnc_graph_exec_symbol_t s_symbol = {
		.d = s,
		.graph = graph->tape
	};
	ccv_nnc_graph_exec_symbol_io(graph->tape, s_symbol, 0, 0, &outputs, &output_size);
	for (j = 0; j < bind->destinations->rnum; j++)
	{
		const int d = *(int*)ccv_array_get(bind->destinations, j)((void*)(((char*)((bind->destinations)->data)) + (size_t
)(bind->destinations)->rsize * (size_t)(j)));
		const ccv_nnc_graph_exec_symbol_t d_symbol = {
			.d = d,
			.graph = graph->tape
		};
		const int* inputs; int input_size;
		ccv_nnc_graph_exec_symbol_io(graph->tape, d_symbol, &inputs, &input_size, 0, 0);
		int x, y;
		int flag = 0; // Whether we find a symbol that connects source and destination but not the current one we detach. If found, we cannot break the tie between s_symbol and d_symbol.
		for (x = 0; !flag && x < output_size; x++)
		{
			ccv_nnc_tensor_symbol_t x_symbol = ccv_nnc_tensor_symbol_alias_to(graph->tape, (ccv_nnc_tensor_symbol_t){
				.d = outputs[x],
				.graph = graph->tape
			});
			if (x_symbol.d == CCV_NNC_NO_TENSOR_SYMBOL)
			{
				x_symbol.d = outputs[x];
				x_symbol.graph = graph->tape;
			}
			if (x_symbol.d == tensor_variable->symbol.d || x_symbol.d == CCV_NNC_NO_TENSOR_SYMBOL)
				continue;
			for (y = 0; !flag && y < input_size; y++)
			{
				ccv_nnc_tensor_symbol_t y_symbol = ccv_nnc_tensor_symbol_alias_to(graph->tape, (ccv_nnc_tensor_symbol_t){
					.d = inputs[y],
					.graph = graph->tape
				});
				if (y_symbol.d == CCV_NNC_NO_TENSOR_SYMBOL)
				{
					y_symbol.d = inputs[y];
					y_symbol.graph = graph->tape;
				}
				if (y_symbol.d == tensor_variable->symbol.d || y_symbol.d == CCV_NNC_NO_TENSOR_SYMBOL)
					continue;
				flag = (x_symbol.d == y_symbol.d);
			}
		}
		if (!flag)
			ccv_nnc_graph_exec_symbol_disjoin(graph->tape, s_symbol, d_symbol);
	}
}
}
const int sources_and_is_only_output = (bind->sources && bind->sources->rnum > 0) && _ccv_nnc_tensor_variable_is_only_output(graph, bind, tensor_variable->symbol.d);
if (!bind->sources || bind->sources->rnum == 0 || sources_and_is_only_output)
{
int ws_start = -1;
_ccv_nnc_tensor_bind_trace_forward_to_free(graph, tensor_variable, bind, bind, &ws_start, 1);
// Because we are detaching from the graph, there is no need to forward trace to see if it is not used and
// then to remove the source execs. We can remove them right now, breaking the graph in two. That is why
// we called trace backward to free regardless the outcome of the forward to free.
if (ws_start == -1)
{
	if (!graph->ws)
		graph->ws = ccv_array_new(sizeof(int), bind->destinations ? bind->destinations->rnum : 0, 0);
	ccv_array_t* const ws = graph->ws;
	ccv_array_clear(ws);
	if (bind->sources)
		for (i = 0; i < bind->sources->rnum; i++)
			ccv_array_add_unique_int(ws, *(int*)ccv_array_get(bind->sources, i)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(i))));
	ws_start = 0;
}
_ccv_nnc_tensor_bind_trace_backward_to_free(graph, graph->ws, ws_start);
}
// If now bind has no relevant sources or destinations, we can safely free the underlying tensor symbol.
if ((!bind->sources || bind->sources->rnum == 0) && (!bind->destinations || bind->destinations->rnum == 0))
{
_ccv_nnc_tensor_variable_graph_bind_free(graph, bind, 1);
ccv_nnc_tensor_symbol_free(graph->tape, tensor_variable->symbol);
tensor_variable->type = CCV_NNC_TENSOR_CONSTANT;
tensor_variable->symbol = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
return;
}
// Mark both as constant, such that even if it cannot be freed now, it can be freed as soon as possible later.
bind->type = CCV_NNC_TENSOR_CONSTANT;
tensor_variable->type = CCV_NNC_TENSOR_CONSTANT;
1361}

1363void ccv_nnc_dynamic_graph_has_effect_to_tensor_variables(const ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_tensor_variable_t* const source_variables, const int source_variable_size, const ccv_nnc_tensor_variable_t* const destination_variables, const int destination_variable_size, uint64_t* const bitmask)
1364{
int i, j;
ccv_array_t* const sources_destinations = ccv_array_new(sizeof(ccv_nnc_graph_exec_symbol_t), source_variable_size + destination_variable_size, 0);
for (i = 0; i < source_variable_size; i++)
{
if (source_variables[i]->symbol.d < 0)
	continue;
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, source_variables[i]->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(source_variables[i]->symbol
.d)));
if (bind->destinations && bind->destinations->rnum > 0)
	for (j = 0; j < bind->destinations->rnum; j++)
	{
		// It is ok to have duplicate symbols.
		const int d = *(int*)ccv_array_get(bind->destinations, j)((void*)(((char*)((bind->destinations)->data)) + (size_t
)(bind->destinations)->rsize * (size_t)(j)));
		ccv_nnc_graph_exec_symbol_t symbol = {
			.d = d,
			.graph = graph->tape
		};
		ccv_array_push(sources_destinations, &symbol);
	}
}
const int source_size = sources_destinations->rnum;
for (i = 0; i < destination_variable_size; i++)
{
if (destination_variables[i]->symbol.d < 0)
	continue;
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, destination_variables[i]->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(destination_variables[i]->
symbol.d)));
if (bind->sources && bind->sources->rnum > 0)
	for (j = 0; j < bind->sources->rnum; j++)
	{
		// It is ok to have duplicate symbols.
		const int d = *(int*)ccv_array_get(bind->sources, j)((void*)(((char*)((bind->sources)->data)) + (size_t)(bind
->sources)->rsize * (size_t)(j)));
		ccv_nnc_graph_exec_symbol_t symbol = {
			.d = d,
			.graph = graph->tape
		};
		ccv_array_push(sources_destinations, &symbol);
	}
}
const int destination_size = sources_destinations->rnum - source_size;
if (source_size == 0 || destination_size == 0)
{
ccv_array_free(sources_destinations);
return;
}
const int bitmask_size = ((source_size + 63) >> 6);
assert(bitmask_size < 256)((void) sizeof ((bitmask_size < 256) ? 1 : 0), __extension__
 ({ if (bitmask_size < 256) ; else __assert_fail ("bitmask_size < 256"
, "ccv_nnc_dynamic_graph.c", 1409, __extension__ __PRETTY_FUNCTION__
); }));
uint64_t exec_bitmask[bitmask_size];
ccv_nnc_symbolic_graph_sources_to_destinations(graph->tape, (ccv_nnc_graph_exec_symbol_t*)ccv_array_get(sources_destinations, 0)((void*)(((char*)((sources_destinations)->data)) + (size_t
)(sources_destinations)->rsize * (size_t)(0))), source_size, (ccv_nnc_graph_exec_symbol_t*)ccv_array_get(sources_destinations, source_size)((void*)(((char*)((sources_destinations)->data)) + (size_t
)(sources_destinations)->rsize * (size_t)(source_size))), destination_size, exec_bitmask);
int k = 0;
for (i = 0; i < source_variable_size; i++)
{
if (source_variables[i]->symbol.d < 0)
{
	bitmask[i >> 6] &= ~((uint64_t)1 << (i & 63));
	continue;
}
ccv_nnc_tensor_variable_graph_bind_t* const bind = (ccv_nnc_tensor_variable_graph_bind_t*)ccv_array_get(graph->binds, source_variables[i]->symbol.d)((void*)(((char*)((graph->binds)->data)) + (size_t)(graph
->binds)->rsize * (size_t)(source_variables[i]->symbol
.d)));
int flag = 0;
if (bind->destinations && bind->destinations->rnum > 0)
{
	assert(k <= source_size - bind->destinations->rnum)((void) sizeof ((k <= source_size - bind->destinations->
rnum) ? 1 : 0), __extension__ ({ if (k <= source_size - bind
->destinations->rnum) ; else __assert_fail ("k <= source_size - bind->destinations->rnum"
, "ccv_nnc_dynamic_graph.c", 1424, __extension__ __PRETTY_FUNCTION__
); }));
	for (j = 0; !flag && j < bind->destinations->rnum; j++)
		flag = (((uint64_t)1 << ((k + j) & 63)) & exec_bitmask[(k + j) >> 6]);
	k += bind->destinations->rnum;
}
if (flag)
	bitmask[i >> 6] |= ((uint64_t)1 << (i & 63));
else
	bitmask[i >> 6] &= ~((uint64_t)1 << (i & 63));
}
ccv_array_free(sources_destinations);
1435}

1437int ccv_nnc_dynamic_graph_bookkeeping_count(const ccv_nnc_dynamic_graph_t* const graph, const int type)
1438{
return ccv_nnc_symbolic_graph_active_symbol_count(graph->tape, type);
1440}

1442void ccv_nnc_dynamic_graph_dot(const ccv_nnc_dynamic_graph_t* const graph, const int flags, FILE* out)
1443{
ccv_nnc_symbolic_graph_dot(graph->tape, flags, out);
1445}

1447void ccv_nnc_dynamic_graph_format(const ccv_nnc_dynamic_graph_t* const graph, const ccv_nnc_symbolic_graph_format_f format_fn, void* const context)
1448{
ccv_nnc_symbolic_graph_format(graph->tape, 0, 0, 0, 0, format_fn, context);
1450}