#include "ccv_nnc.h"

#include "ccv_nnc_easy.h"

#include "ccv_nnc_internal.h"

#include "ccv_internal.h"

#include "_ccv_cnnp_model.h"

#include "_ccv_nnc_graph.h"

// MARK - Level-5 API

ccv_cnnp_model_io_t ccv_cnnp_model_apply(ccv_cnnp_model_t* const model, const ccv_cnnp_model_io_t* const inputs, const int input_size)

{

  if (!model->io)

    model->io = ccv_array_new(sizeof(ccv_cnnp_model_io_t), 1, 0);

  ccv_cnnp_model_io_t model_io = ccmalloc(sizeof(struct ccv_cnnp_model_io_s) + sizeof(ccv_nnc_tensor_symbol_t) * model->output_size);

  model_io->param_ref = 0;

  model_io->param_sel = 0;

  model_io->visit = 0;

  model_io->model = model;

  model_io->dependencies = 0;

  model_io->dependents = 0;

  model_io->outgoings = 0;

  model_io->outputs = (ccv_nnc_tensor_symbol_t*)(model_io + 1);

  ccv_array_push(model->io, &model_io);

  if (input_size > 0)

  {

    model_io->incomings = ccv_array_new(sizeof(ccv_cnnp_model_io_t), input_size, 0);

    ccv_array_resize(model_io->incomings, input_size);

    int i;

    memcpy(ccv_array_get(model_io->incomings, 0), inputs, sizeof(ccv_cnnp_model_io_t) * input_size);

    for (i = 0; i < input_size; 
i++680
)

    {

      if (!inputs[i]->outgoings)

        inputs[i]->outgoings = ccv_array_new(sizeof(ccv_cnnp_model_io_t), 1, 0);

      ccv_array_push(inputs[i]->outgoings, &model_io);

    }

  } else {

    model_io->incomings = 0;

  }

  return model_io;

}

void ccv_cnnp_model_add_dependencies(ccv_cnnp_model_io_t model_io, const ccv_cnnp_model_io_t* const dependencies, const int dependency_size)

{

  assert(dependency_size > 0);

  if (!model_io->dependencies)

    model_io->dependencies = ccv_array_new(sizeof(ccv_cnnp_model_io_t), dependency_size, 0);

  int i, j;

  for (i = 0; i < dependency_size; 
i++3
)

  {

    int flag = 0;

    // Check if it is already exist or not.

    for (j = 0; !flag && j < model_io->dependencies->rnum; 
j++1
)

      if (*(ccv_cnnp_model_io_t*)ccv_array_get(model_io->dependencies, j) == dependencies[i])

        flag = 1;

    if (flag)

      continue;

    ccv_array_push(model_io->dependencies, dependencies + i);

    ++dependencies[i]->dependents;

  }

}

int ccv_cnnp_model_output_size(const ccv_cnnp_model_t* const model)

{

  return model->output_size;

}

int ccv_cnnp_model_is_trainable(const ccv_cnnp_model_t* const model)

{

  // If the model is compiled, it is default to 1 unless it is not.

  if (model->compiled_data)

    return model->is_trainable >= 0 ? model->is_trainable : 
10
;

  return model->is_trainable;

}

ccv_cnnp_model_io_t ccv_cnnp_model_parameters(ccv_cnnp_model_t* const model, const int selector, const int index)

{

  if (!model->io)

    model->io = ccv_array_new(sizeof(ccv_cnnp_model_io_t), 1, 0);

  ccv_cnnp_model_io_t model_io = ccmalloc(sizeof(struct ccv_cnnp_model_io_s));

  model_io->param_ref = index >= 0 ? 
index + 137
 : 
ALL_PARAMETERS352
;

  model_io->param_sel = selector >= 0 ? 
selector + 1308
 : 
ALL_PARAMETERS81
;

  model_io->visit = 0;

  model_io->model = model;

  model_io->outputs = 0;

  model_io->dependencies = 0;

  model_io->dependents = 0;

  model_io->incomings = 0;

  model_io->outgoings = 0;

  ccv_array_push(model->io, &model_io);

  return model_io;

}

void ccv_cnnp_model_notify_hook(ccv_cnnp_model_t* const model, ccv_cnnp_model_notify_f func, void* const context)

{

  model->notify_hook.func = func;

  model->notify_hook.context = context;

}

void ccv_cnnp_model_notify(const ccv_cnnp_model_t* const model, const int tag, void* const payload)

{

  if (model->notify_hook.func)

    model->notify_hook.func(model, tag, payload, model->notify_hook.context);

  if (model->isa->notify)

    model->isa->notify(model, tag, payload);

}

static int _ccv_nnc_array_dedup_graph_exec_symbols(ccv_nnc_graph_exec_symbol_t* const graph_exec_symbols, int graph_exec_symbol_size)

{

  int i, j;

  for (i = 0; i < graph_exec_symbol_size; 
i++2.60k
)

  {

    ccv_nnc_graph_exec_symbol_t* const graph_exec_symbol = graph_exec_symbols + i;

    // Check whether this tensor symbol has any duplicate.

    for (j = i + 1; j < graph_exec_symbol_size;)

    {

      ccv_nnc_graph_exec_symbol_t* const other_symbol = graph_exec_symbols + j;

      // If there is a same tensor symbol, remove it.

      if (other_symbol->d == graph_exec_symbol->d && 
other_symbol->graph == graph_exec_symbol->graph2.70k
)

      {

        if (j + 1 < graph_exec_symbol_size)

          *other_symbol = graph_exec_symbols[graph_exec_symbol_size - 1];

        --graph_exec_symbol_size;

        continue;

      }

      ++j;

    }

  }

  return graph_exec_symbol_size;

}

void ccv_cnnp_model_add_to_array(void* const context, const ccv_nnc_tensor_symbol_t symbol, const int is_trainable)

{

  ccv_cnnp_model_add_to_array_context_t* const add_to_array_context = (ccv_cnnp_model_add_to_array_context_t*)context;

  ccv_cnnp_model_t* const model = add_to_array_context->sequence->model;

  int i;

  if (add_to_array_context->add_parameter_indices && 
!model->parameter_indices2.96k
)

    model->parameter_indices = ccv_array_new(sizeof(int), 0, 0);

  for (i = 0; i < add_to_array_context->symbols->rnum; 
i++33.9k
)

  {

    const ccv_nnc_tensor_symbol_t other_symbol = *(ccv_nnc_tensor_symbol_t*)ccv_array_get(add_to_array_context->symbols, i);

    if (other_symbol.d == symbol.d && 
other_symbol.graph == symbol.graph24
)

    {

      // Only add to parameter_indices if it is trainable.

      if (add_to_array_context->add_parameter_indices)

        ccv_array_add_unique_int(model->parameter_indices, i);

      // Found it, return, don't add it.

      return;

    }

  }

  // Only add to parameter_indices if it is trainable.

  if (add_to_array_context->add_parameter_indices)

    ccv_array_push(model->parameter_indices, &add_to_array_context->symbols->rnum);

  // This is a new one, no need to add_unique_int, it is unique.

  ccv_array_push(add_to_array_context->symbols, &symbol);

  if (add_to_array_context->trainables)

    ccv_array_push(add_to_array_context->trainables, &is_trainable);

  char id[2048];

  id[0] = add_to_array_context->prefix;

  id[1] = '-';

  int total_len = 2;

  for (i = 0; i < add_to_array_context->sequence->sequences->rnum; 
i++3.34k
)

  {

    const ccv_cnnp_model_name_t* const name = (ccv_cnnp_model_name_t*)ccv_array_get(add_to_array_context->sequence->sequences, i);

    int len;

    if (name->name && 
name->name[0] != '\0'345
)

      len = snprintf(id + total_len, 2048 - total_len, "%s-%d-", name->name, name->sequence);

    else

      len = snprintf(id + total_len, 2048 - total_len, "%d-", name->sequence);

    total_len += len;

    if (total_len >= 2047)

      break;

  }

  if (total_len < 2047)

    total_len += snprintf(id + total_len, 2048 - total_len, "%d", add_to_array_context->sequence->it);

  assert(total_len < 2048);

  char *heap_id = (char*)ccmalloc(total_len + 1);

  memcpy(heap_id, id, total_len + 1);

  ccv_array_push(add_to_array_context->ids, &heap_id);

  ++add_to_array_context->sequence->it;

}

static void _ccv_cnnp_compiled_data_init(ccv_cnnp_compiled_data_t* const compiled_data, const int output_size, ccv_array_t* const gradient_checkpoints)

{

  compiled_data->f = compiled_data->fits + output_size;

  compiled_data->xpu_alloc.mp_hdr = -1;

  compiled_data->xpu_alloc.freed = kh_init(dy_str);

  compiled_data->xpu_alloc.allocd = kh_init(dy_alloc);

  compiled_data->gradient_checkpoints = gradient_checkpoints;

}

static void _ccv_cnnp_model_compile(ccv_cnnp_model_t* const model, const ccv_nnc_tensor_param_t* const inputs, const int input_size, const ccv_nnc_cmd_t loss)

{

  assert(model->graph);

  model->inputs = ccmalloc(sizeof(ccv_nnc_tensor_symbol_t) * input_size);

  int i;

  for (i = 0; i < input_size; 
i++2.35k
)

    model->inputs[i] = ccv_nnc_tensor_symbol_new(model->graph, inputs[i], 0);

  ccv_array_t* const parameters = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);

  ccv_array_t* const parameter_ids = ccv_array_new(sizeof(char*), 0, 0);

  ccv_array_t* const parameter_trainables = ccv_array_new(sizeof(int), 0, 0);

  ccv_cnnp_model_sequence_t model_sequence = {

    .bank = kh_init(ccv_cnnp_model_name_bank)

  };

  ccv_cnnp_model_add_to_array_context_t add_to_parameter_context = {

    .add_parameter_indices = 1,

    .prefix = 't',

    .sequence = &model_sequence,

    .symbols = parameters,

    .ids = parameter_ids,

    .trainables = parameter_trainables,

  };

  ccv_array_t* const internals = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);

  ccv_array_t* const internal_ids = ccv_array_new(sizeof(char*), 0, 0);

  ccv_cnnp_model_add_to_array_context_t add_to_output_context = {

    .add_parameter_indices = 0,

    .prefix = 'r',

    .sequence = &model_sequence,

    .symbols = internals,

    .ids = internal_ids,

    .trainables = 0,

  };

  ccv_cnnp_model_build_data_t build_data = {

    .is_trainable = model->is_trainable >= 0 ? 
model->is_trainable2.28k
 : 
14
,

    .model_sequence = &model_sequence,

    .add_to_array = ccv_cnnp_model_add_to_array,

    .parameters = parameters,

    .context = {

      .add_to_parameter = &add_to_parameter_context,

      .add_to_output = &add_to_output_context,

    },

    .gradient_checkpoints = 0,

  };

  model->data = &build_data;

  ccv_cnnp_model_build(model, model->graph, model->inputs, input_size, 0, 0);

  for (i = 0; i < model->output_size; 
i++2.30k
)

  {

    const ccv_nnc_tensor_symbol_t output = model->outputs[i];

    const ccv_nnc_tensor_symbol_t alias_to = ccv_nnc_tensor_symbol_alias_to(model->graph, output);

    if (alias_to.d == CCV_NNC_NO_TENSOR_SYMBOL)

      continue;

    // If output is an alias, insert data transform regardless for result correctness (we cannot bind an alias). You can check ccv_nnc_tensor_bind_symbol method

    // to see that we can correctly bind a tensor which from it, has aliases, but we cannot bind an alias tensor correctly (this is expected, sort of, to be

    // honest, because we cannot handle cases of alias is part of the original tensor but bind differently).

    const ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(model->graph, output);

    model->outputs[i] = ccv_nnc_tensor_symbol_new(model->graph, output_params, 0);

    ccv_nnc_graph_exec_symbol_t make_contiguous = ccv_nnc_graph_exec_symbol_new(model->graph, CMD_FORMAT_TRANSFORM_FORWARD(), &output, 1, model->outputs + i, 1, "contiguous");

    ccv_nnc_graph_exec_symbol_set_flags(model->graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);

  }

  model->data = 0;

  kh_destroy(ccv_cnnp_model_name_bank, model_sequence.bank);

  if (model_sequence.sequences)

    ccv_array_free(model_sequence.sequences);

  // Check if there are parameters that are not trainables. If there are, we will allocate uint64 bitmap to record that.

  int not_trainables = 0;

  // Assert no parameter is alias.

  for (i = 0; i < parameters->rnum; 
i++2.94k
)

  {

    const ccv_nnc_tensor_symbol_t parameter = *(ccv_nnc_tensor_symbol_t*)ccv_array_get(parameters, i);

    const ccv_nnc_tensor_symbol_t alias_to = ccv_nnc_tensor_symbol_alias_to(parameter.graph, parameter);

    assert(alias_to.graph == 0); // Cannot find the one alias to.

    if (*(int*)ccv_array_get(parameter_trainables, i) == 0)

      not_trainables = 1;

  }

  assert(parameters->rnum == parameter_trainables->rnum);

  uint64_t* parameter_flags = 0;

  if (not_trainables)

  {

    parameter_flags = (uint64_t*)cccalloc(((parameters->rnum + 63) >> 6), sizeof(uint64_t));

    for (i = 0; i < parameter_trainables->rnum; 
i++31
)

      if (*(int*)ccv_array_get(parameter_trainables, i))

        parameter_flags[i >> 6] |= ((uint64_t)1 << (i & 63));

  }

  ccv_array_free(parameter_trainables);

  // Assert no internal is alias.

  for (i = 0; i < internals->rnum; 
i++161
)

  {

    const ccv_nnc_tensor_symbol_t internal = *(ccv_nnc_tensor_symbol_t*)ccv_array_get(internals, i);

    const ccv_nnc_tensor_symbol_t alias_to = ccv_nnc_tensor_symbol_alias_to(internal.graph, internal);

    assert(alias_to.graph == 0); // Cannot find the one alias to.

  }

  const int output_size = model->output_size;

  ccv_nnc_graph_exec_symbol_autogen(model->graph, 0, 0, CCV_NNC_AUTOGEN_ALL_EXECS | CCV_NNC_AUTOGEN_SOURCES_AND_DESTINATIONS);

  const int parameters_rnum = parameters->rnum;

  if (input_size > 0)

  {

    ccv_array_resize(parameters, parameters_rnum + input_size);

    memcpy(ccv_array_get(parameters, parameters_rnum), model->inputs, input_size * sizeof(ccv_nnc_tensor_symbol_t));

  }

  ccv_nnc_symbolic_graph_simplify(model->graph,

    SYMBOLIC_GRAPH_PASSES(CCV_NNC_SIMPLIFY_COMMON_SUBEXPRESSION_ELIMINATION,

      CCV_NNC_SIMPLIFY_DATA_TRANSFER_OPT,

      CCV_NNC_SIMPLIFY_OPS_FUSION,

      CCV_NNC_SIMPLIFY_GRAPH_PRUNING),

    ccv_array_get(parameters, 0), parameters_rnum + input_size,

    model->outputs, output_size,

    SYMBOLIC_GRAPH_SOURCES(model->graph), SYMBOLIC_GRAPH_DESTINATIONS(model->graph));

  ccv_nnc_graph_exec_symbol_autogen(model->graph, 0, 0, CCV_NNC_AUTOGEN_SOURCES_AND_DESTINATIONS);

  // Size it down.

  parameters->rnum = parameters_rnum;

  ccv_cnnp_compiled_data_t* compiled_data = model->compiled_data = cccalloc(1, sizeof(ccv_cnnp_compiled_data_t) + sizeof(ccv_nnc_tensor_symbol_t) * (output_size * 2 - 1));

  _ccv_cnnp_compiled_data_init(compiled_data, output_size, build_data.gradient_checkpoints);

  const int evaluate_to_size = compiled_data->evaluate.to_size = ccv_nnc_symbolic_graph_destination_size(model->graph);

  assert(evaluate_to_size > 0);

  compiled_data->evaluate.tos = ccmalloc(sizeof(ccv_nnc_graph_exec_symbol_t) * evaluate_to_size);

  memcpy(compiled_data->evaluate.tos, ccv_nnc_symbolic_graph_destinations(model->graph), sizeof(ccv_nnc_graph_exec_symbol_t) * evaluate_to_size);

  compiled_data->loss = loss;

  if (loss.cmd == CCV_NNC_NOOP)

  {

    // If no loss function provided, there is no fits.

    for (i = 0; i < output_size; 
i++2.29k
)

    {

      compiled_data->fits[i] = NO_TENSOR_SYMBOL;

      const ccv_nnc_tensor_symbol_t alias_to = ccv_nnc_tensor_symbol_alias_to(model->graph, model->outputs[i]);

      if (alias_to.d < 0)

        compiled_data->f[i] = model->outputs[i];

      else { // We cannot differentiate against an alias, therefore, we have to verify this output is full, and we can diff against the original.

        int ofs[CCV_NNC_MAX_DIM_ALLOC];

        int inc[CCV_NNC_MAX_DIM_ALLOC];

        ccv_nnc_tensor_symbol_alias_params(model->graph, model->outputs[i], ofs, inc);

        int j;

        for (j = 0; j < CCV_NNC_MAX_DIM_ALLOC; j++)

          { assert(ofs[j] == 0); } // There is no ofs.

        compiled_data->f[i] = alias_to; // Unfortunately, I cannot assert the size yet.

      }

    }

  } else {

    for (i = 0; i < output_size; 
i++10
)

    {

      const ccv_nnc_tensor_param_t info = ccv_nnc_tensor_symbol_params(model->graph, model->outputs[i]);

      const ccv_nnc_tensor_symbol_t fit = compiled_data->fits[i] = ccv_nnc_tensor_symbol_new(model->graph, info, 0);

      compiled_data->f[i] = ccv_nnc_tensor_symbol_new(model->graph, ccv_nnc_tensor_auto, 0);

      ccv_nnc_graph_exec_symbol_new(model->graph, loss, TENSOR_SYMBOL_LIST(model->outputs[i], fit), TENSOR_SYMBOL_LIST(compiled_data->f[i]), 0);

    }

  }

  ccv_nnc_graph_exec_symbol_autogen(model->graph, 0, 0, CCV_NNC_AUTOGEN_ALL_EXECS | CCV_NNC_AUTOGEN_SOURCES_AND_DESTINATIONS);

  ccv_nnc_symbolic_graph_simplify(model->graph,

    SYMBOLIC_GRAPH_PASSES(CCV_NNC_SIMPLIFY_OPS_FUSION), // Only do Ops fusion, in this way, we can fuse the loss function.

    0, 0, // No need to provide binds at this point.

    compiled_data->f, model->output_size,

    SYMBOLIC_GRAPH_SOURCES(model->graph), SYMBOLIC_GRAPH_DESTINATIONS(model->graph));

  ccv_nnc_graph_exec_symbol_autogen(model->graph, 0, 0, CCV_NNC_AUTOGEN_SOURCES_AND_DESTINATIONS);

  // If inputs are from GPU, stream type is GPU.

  compiled_data->parameters = parameters;

  compiled_data->parameter_flags = parameter_flags;

  compiled_data->internals = internals;

  compiled_data->ids.parameters = parameter_ids;

  compiled_data->ids.internals = internal_ids;

  ccv_cnnp_model_gradient_checkpoints_cleanup_after_build(compiled_data, model->graph);

}

static void _ccv_cnnp_graph_push_graph_exec_symbol(void* context, const ccv_nnc_graph_exec_symbol_t symbol, const ccv_nnc_cmd_t cmd, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, const ccv_nnc_tensor_symbol_t* const outputs, const int output_size, const char* const name)

{

  ccv_array_t* const stack = (ccv_array_t*)context;

  ccv_array_push(stack, &symbol.d);

}

static void _ccv_nnc_tensor_symbol_reinit(const ccv_nnc_symbolic_graph_t* const src_graph, ccv_nnc_symbolic_graph_t* const dest_graph, const int src_index, const int dest_index)

{

  const ccv_nnc_tensor_symbol_t src_symbol = {

    .d = src_index,

    .graph = src_graph

  };

  const ccv_nnc_tensor_symbol_t dest_symbol = {

    .d = dest_index,

    .graph = dest_graph

  };

  const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(src_graph, src_symbol);

  ccv_nnc_tensor_symbol_set(dest_graph, dest_symbol, params);

  int ofs[CCV_NNC_MAX_DIM_ALLOC];

  int inc[CCV_NNC_MAX_DIM_ALLOC];

  if (0 == ccv_nnc_tensor_symbol_alias_params(src_graph, src_symbol, ofs, inc))

    ccv_nnc_tensor_symbol_alias_set(dest_graph, dest_symbol, ofs, inc);

}

static int _ccv_nnc_tensor_symbol_check_dim(const ccv_nnc_symbolic_graph_t* const src_graph, ccv_nnc_symbolic_graph_t* const dest_graph, const int src_index, const int dest_index)

{

  const ccv_nnc_tensor_symbol_t src_symbol = {

    .d = src_index,

    .graph = src_graph

  };

  const ccv_nnc_tensor_param_t src_params = ccv_nnc_tensor_symbol_params(src_graph, src_symbol);

  const ccv_nnc_tensor_symbol_t dest_symbol = {

    .d = dest_index,

    .graph = dest_graph

  };

  const ccv_nnc_tensor_param_t dest_params = ccv_nnc_tensor_symbol_params(dest_graph, dest_symbol);

  return memcmp(src_params.dim, dest_params.dim, sizeof(src_params.dim)) == 0;

}

static void _ccv_cnnp_model_gradient_init(ccv_cnnp_model_t* const model, const int gradient_mode, const uint64_t disable_outgrad, ccv_nnc_tensor_t* const* const fits, const int fit_size);

static void _ccv_cnnp_compiled_data_graph_free(ccv_cnnp_compiled_data_t* const compiled_data);

typedef struct {

  int parallel_count;

  ccv_nnc_symbolic_graph_t* graph;

  ccv_nnc_graph_exec_arena_t* graph_exec_arena;

} ccv_nnc_graph_exec_update_t;

static void _ccv_cnnp_cmd_update_for_execs(void* const context, const ccv_nnc_graph_exec_symbol_t symbol, const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint)

{

  ccv_nnc_graph_exec_update_t* const graph_exec_update = (ccv_nnc_graph_exec_update_t*)context;

  ccv_nnc_graph_exec_arena_t* const graph_exec_arena = graph_exec_update->graph_exec_arena;

  ccv_nnc_graph_exec_t graph_exec = ccv_nnc_graph_exec_from_symbol(graph_exec_arena, symbol);

  ccv_nnc_graph_exec_set(graph_exec.graph, graph_exec, cmd);

  ccv_nnc_graph_exec_set_hint(graph_exec.graph, graph_exec, hint);

  const ccv_nnc_symbolic_graph_t* const graph = graph_exec_update->graph;

  const int parallel_count = graph_exec_update->parallel_count;

  int i;

  for (i = 1; i < parallel_count; 
i++120
)

  {

    const ccv_nnc_graph_exec_t copy = ccv_nnc_graph_exec_from_symbol(graph_exec_arena, ccv_nnc_graph_exec_symbol_copy(graph, symbol, i));

    if (!CCV_NO_GRAPH_EXEC(copy))

    {

      ccv_nnc_graph_exec_set(copy.graph, copy, cmd);

      ccv_nnc_graph_exec_set_hint(copy.graph, copy, hint);

    }

  }

}

void ccv_cnnp_model_absorb(ccv_cnnp_model_t* const model, ccv_cnnp_model_t* const init, const ccv_nnc_tensor_param_t* const inputs, const int input_size)

{

  assert(model->graph);

  assert(model->compiled_data);

  assert(!init->graph);

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  init->graph = ccv_nnc_symbolic_graph_new();

  ccv_array_t* const stack = ccv_array_new(sizeof(int), 0, 0);

  ccv_nnc_graph_exec_symbol_new_hook(init->graph, _ccv_cnnp_graph_push_graph_exec_symbol, stack, 0);

  _ccv_cnnp_model_compile(init, inputs, input_size, compiled_data->loss);

  init->parallel_count = model->parallel_count;

  init->memory_compression = model->memory_compression;

  init->memory_reduction = model->memory_reduction;

  init->gradient_checkpointing = model->gradient_checkpointing;

  init->compiled_data->stream_type = model->compiled_data->stream_type;

  init->compiled_data->minimize.minimizer = model->compiled_data->minimize.minimizer;

  init->compiled_data->minimize.max_saved_aux_size = model->compiled_data->minimize.max_saved_aux_size;

  if (model->compiled_data->gradient_mode != CCV_CNNP_COMPILED_DATA_GRADIENT_NONE)

    _ccv_cnnp_model_gradient_init(init, model->compiled_data->gradient_mode, model->compiled_data->disable_outgrad, 0, 0);

  ccv_nnc_graph_exec_symbol_new_hook(init->graph, 0, 0, 0);

  ccv_nnc_symbolic_graph_tensor_auto(init->graph, TRAVERSE_FULL);

  int i, j;

  // Verify parameters, internals and saved_aux in both graph has the same dimensionality.

  for (i = 0; i < compiled_data->parameters->rnum; 
i++2.41k
)

  {

    const int d = ((ccv_nnc_tensor_symbol_t*)ccv_array_get(compiled_data->parameters, i))->d;

    assert(_ccv_nnc_tensor_symbol_check_dim(model->graph, init->graph, d, d));

  }

  for (i = 0; i < compiled_data->internals->rnum; 
i++0
)

  {

    const int d = ((ccv_nnc_tensor_symbol_t*)ccv_array_get(compiled_data->internals, i))->d;

    assert(_ccv_nnc_tensor_symbol_check_dim(model->graph, init->graph, d, d));

  }

  // Update inputs.

  assert(model->input_size == init->input_size);

  
for (i = 0; 2.20k
i < model->input_size; 
i++2.20k
)

    if (model->inputs[i].d >= 0)

    {

      assert(init->inputs[i].d >= 0);

      _ccv_nnc_tensor_symbol_reinit(init->graph, model->graph, init->inputs[i].d, model->inputs[i].d);

    }

  // Update outputs.

  assert(model->output_size == init->output_size);

  
for (i = 0; 2.20k
i < model->output_size; 
i++2.20k
)

  {

    if (model->outputs[i].d >= 0)

    {

      assert(init->outputs[i].d >= 0);

      _ccv_nnc_tensor_symbol_reinit(init->graph, model->graph, init->outputs[i].d, model->outputs[i].d);

    }

    if (model->outputs[i].d != model->compiled_data->f[i].d)

    {

      assert(init->outputs[i].d != init->compiled_data->f[i].d);

      if (model->compiled_data->f[i].d >= 0)

      {

        assert(init->compiled_data->f[i].d >= 0);

        _ccv_nnc_tensor_symbol_reinit(init->graph, model->graph, init->compiled_data->f[i].d, model->compiled_data->f[i].d);

      }

    }

  }

  // Go through the graph to set tensor on matching symbols

  
for (i = 0; 2.20k
i < stack->rnum; 
i++8.82k
)

  {

    const int d = *(int*)ccv_array_get(stack, i);

    // If exceed range, skip.

    if (d >= ccv_nnc_graph_exec_symbol_count(init->graph) ||

      d >= ccv_nnc_graph_exec_symbol_count(model->graph))

      continue;

    const ccv_nnc_graph_exec_symbol_t src_symbol = {

      .d = d,

      .graph = init->graph

    };

    const ccv_nnc_graph_exec_symbol_t dest_symbol = {

      .d = d,

      .graph = model->graph

    };

    const ccv_nnc_cmd_t src_cmd = ccv_nnc_graph_exec_symbol_cmd(init->graph, src_symbol);

    const ccv_nnc_cmd_t dest_cmd = ccv_nnc_graph_exec_symbol_cmd(model->graph, dest_symbol);

    // If the name doesn't match, skip.

    if (dest_cmd.cmd != src_cmd.cmd && 
src_cmd.cmd != CCV_NNC_NOOP0
)

      continue;

    // Now get all the inputs and outputs, if matches, set them.

    const int* src_inputs;

    int src_input_size;

    const int* src_outputs;

    int src_output_size;

    ccv_nnc_graph_exec_symbol_io(init->graph, src_symbol, &src_inputs, &src_input_size, &src_outputs, &src_output_size);

    const int* dest_inputs;

    int dest_input_size;

    const int* dest_outputs;

    int dest_output_size;

    ccv_nnc_graph_exec_symbol_io(model->graph, dest_symbol, &dest_inputs, &dest_input_size, &dest_outputs, &dest_output_size);

    // We may have unmatched input / output size because this is the minimizer and it has

    // different saved_aux (for example, when we shrunk with CMD_NOOP).

    if (src_input_size != dest_input_size)

      continue;

    if (src_output_size != dest_output_size)

      continue;

    ccv_nnc_graph_exec_symbol_set(model->graph, dest_symbol, src_cmd);

    // There may be mismatches of the source tensor symbols and destination tensor symbols. The reason is because

    // we may later passed-in the minimizer, therefore, we may allocate tensors for minimizer later in the original

    // graph whereas in the newly created graph, it is streamlined (the minimizer exists from the beginning). That

    // will make the order of tensor symbols creation different, therefore, exact which tensor is which wrong as

    // well. However, set a new minimizer won't change the exec symbol ordering, because we never create new exec

    // symbols after gradient init step. Changing a new minimizer just updated that exec symbols setting, it is not

    // a new exec symbol.

    for (j = 0; j < src_input_size; 
j++24.8k
)

      if (src_inputs[j] >= 0)

        _ccv_nnc_tensor_symbol_reinit(init->graph, model->graph, src_inputs[j], dest_inputs[j]);

    for (j = 0; j < src_output_size; 
j++13.6k
)

      if (src_outputs[j] >= 0)

        _ccv_nnc_tensor_symbol_reinit(init->graph, model->graph, src_outputs[j], dest_outputs[j]);

  }

  ccv_array_free(stack);

  // After this, we get all tensors in the model graph resolved through tensor_auto.

  ccv_nnc_symbolic_graph_tensor_auto(model->graph, TRAVERSE_FULL);

  // Verify symbols we get matches.

  const int parameter_size = compiled_data->parameters->rnum;

  for (i = 0; i < parameter_size; 
i++2.41k
)

    { assert(((ccv_nnc_tensor_symbol_t*)ccv_array_get(compiled_data->parameters, i))->d == ((ccv_nnc_tensor_symbol_t*)ccv_array_get(init->compiled_data->parameters, i))->d); }

  const int internal_size = compiled_data->internals->rnum;

  for (i = 0; i < internal_size; 
i++0
)

    { assert(((ccv_nnc_tensor_symbol_t*)ccv_array_get(compiled_data->internals, i))->d == ((ccv_nnc_tensor_symbol_t*)ccv_array_get(init->compiled_data->internals, i))->d); }

  // Go through compiled data.

  if (compiled_data->tensor_arena)

  {

    const int flag = ccv_nnc_tensor_arena_reinit(compiled_data->tensor_arena, model->graph);

    if (flag == 0 && compiled_data->graph_exec_arena)

    {

      ccv_nnc_graph_exec_reinit(compiled_data->graph_exec_arena, compiled_data->graph, model->graph);

      // Since we will reinit, if we previously set is_test, we need to set it again.

      if (compiled_data->is_test)

      {

        const int parallel_count = ccv_max(model->parallel_count, 1);

        ccv_nnc_graph_exec_update_t update = {

          .parallel_count = parallel_count,

          .graph = model->graph,

          .graph_exec_arena = compiled_data->graph_exec_arena,

        };

        ccv_cnnp_model_set_is_test(model, 1, _ccv_cnnp_cmd_update_for_execs, &update);

      }

    } else

      // Free-up tensor arena & graph exec arena.

      _ccv_cnnp_compiled_data_graph_free(compiled_data);

  }

  // There are other compiled graphs, for accum and apply gradients.

  // However, the main conclusion is, these absorb operations shouldn't impact parameters.

  // Thus, it won't impact the shape of gradients (only outgrad). Since for outgrad, we

  // don't allocate ourselves, it is not a concern. For normal gradients, the shape cannot

  // be changed otherwise parameters' shape will be meaningless. The same goes to internals.

  // That is why we don't update these compiled graphs at all this point.

  // Free the model, we've already "absorbed" it.

  ccv_cnnp_model_free(init);

}

void ccv_cnnp_model_compile(ccv_cnnp_model_t* const model, const ccv_nnc_tensor_param_t* const inputs, const int input_size, const ccv_nnc_cmd_t minimizer, const ccv_nnc_cmd_t loss)

{

  assert(input_size == model->input_size || model->input_size == 0);

  if (model->input_size == 0)

    model->input_size = input_size;

  if (!model->graph) // The graph is not compiled yet.

  {

    model->graph = ccv_nnc_symbolic_graph_new();

    _ccv_cnnp_model_compile(model, inputs, input_size, loss);

    assert(model->compiled_data);

    int i, flag = 0;

    for (i = 0; !flag && 
i < input_size197
; 
i++130
)

      flag = (CCV_TENSOR_GET_MEMORY(inputs[i].type) == CCV_TENSOR_GPU_MEMORY);

    // If inputs are from GPU, stream type is GPU.

    model->compiled_data->stream_type = flag ? 
CCV_STREAM_CONTEXT_GPU20
 : 
CCV_STREAM_CONTEXT_CPU67
;

    model->compiled_data->minimize.minimizer = minimizer;

    model->compiled_data->minimize.max_saved_aux_size = ccv_nnc_minimizer_saved_aux_size(minimizer);

  } else {

    // Now, finally fill in this part. If the graph is already compiled, we make a copy of the model.

    // And then absorb the "new model" to the old one.

    ccv_cnnp_model_t* const init = ccv_cnnp_model_copy(model, model->is_trainable);

    ccv_cnnp_model_absorb(model, init, inputs, input_size);

    // Reset minimizer.

    ccv_cnnp_model_set_minimizer(model, minimizer, 1, 0, 0);

  }

}

ccv_cnnp_model_t* ccv_cnnp_model_copy(const ccv_cnnp_model_t* const model, const int is_trainable)

{

  ccv_cnnp_model_t* const new_model = _ccv_cnnp_model_copy(model, 0);

  new_model->is_trainable = is_trainable;

  return new_model;

}

void ccv_cnnp_model_tensor_auto(ccv_cnnp_model_t* const model, ccv_nnc_tensor_param_t* const outputs, const int output_size)

{

  assert(model->graph);

  assert(output_size == model->output_size);

  ccv_nnc_symbolic_graph_t* const graph = model->graph;

  ccv_nnc_symbolic_graph_tensor_auto(graph, TRAVERSE_FULL);

  int i;

  for (i = 0; i < output_size; 
i++4.44k
)

  {

    assert(model->outputs[i].d != CCV_NNC_NO_TENSOR_SYMBOL);

    outputs[i] = ccv_nnc_tensor_symbol_params(graph, model->outputs[i]);

  }

}

void ccv_cnnp_model_set_workspace_size(ccv_cnnp_model_t* const model, size_t workspace_size)

{

  if (workspace_size == model->workspace_size)

    return;

  model->workspace_size = workspace_size;

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  if (compiled_data && compiled_data->graph)

    ccv_nnc_graph_autotune(compiled_data->graph, workspace_size, 0, TRAVERSE_FULL);

}

size_t ccv_cnnp_model_workspace_size(ccv_cnnp_model_t* const model)

{

  return model->workspace_size;

}

void ccv_cnnp_model_set_data_parallel(ccv_cnnp_model_t* const model, const int parallel)

{

  if (parallel == 0)

    model->parallel_count = ccv_nnc_device_count(CCV_STREAM_CONTEXT_GPU);

  else

    model->parallel_count = parallel;

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  if (compiled_data)

    { assert(!compiled_data->graph); }

}

void ccv_cnnp_model_set_max_concurrency(ccv_cnnp_model_t* const model, const int max_stream_count)

{

  model->max_stream_count = max_stream_count;

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  if (compiled_data)

    { assert(!compiled_data->graph); }

}

void ccv_cnnp_model_set_memory_compression(ccv_cnnp_model_t* const model, const int memory_compression)

{

  model->memory_compression = memory_compression;

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  if (compiled_data)

    { assert(!compiled_data->graph); }

}

void ccv_cnnp_model_set_memory_reduction(ccv_cnnp_model_t* const model, const int memory_reduction)

{

  model->memory_reduction = memory_reduction;

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  if (compiled_data)

    { assert(!compiled_data->graph); }

}

void ccv_cnnp_model_set_gradient_checkpointing(ccv_cnnp_model_t* const model, const int gradient_checkpointing)

{

  model->gradient_checkpointing = gradient_checkpointing;

}

int ccv_cnnp_model_gradient_checkpointing(ccv_cnnp_model_t* const model)

{

  return model->gradient_checkpointing;

}

typedef struct {

  int parallel_count;

  ccv_nnc_symbolic_graph_t* graph;

  ccv_cnnp_compiled_data_t* compiled_data;

  ccv_nnc_tensor_arena_t* tensor_arena;

} ccv_nnc_tensor_init_states_t;

static int _ccv_cnnp_any_to_init(const ccv_cnnp_compiled_data_t* const compiled_data)

{

  int i;

  const uint32_t* const init_v = CCV_NNC_INIT_V(compiled_data->tensors_init.v);

  for (i = 0; i < compiled_data->parameters->rnum; 
i++76
)

  {

    const int d = ((ccv_nnc_tensor_symbol_t*)ccv_array_get(compiled_data->parameters, i))->d;

    if (!(init_v[d >> 5] & (1u << (d & 0x1f))))

      return 1;

  }

  for (i = 0; i < compiled_data->internals->rnum; 
i++0
)

  {

    const int d = ((ccv_nnc_tensor_symbol_t*)ccv_array_get(compiled_data->internals, i))->d;

    if (!(init_v[d >> 5] & (1u << (d & 0x1f))))

      return 1;

  }

  return 0;

}

static void _ccv_cnnp_init_states_for_tensors(void* const context, const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const input, const ccv_nnc_tensor_symbol_t output_symbol)

{

  ccv_nnc_tensor_init_states_t* const tensor_init_states = (ccv_nnc_tensor_init_states_t*)context;

  ccv_nnc_tensor_arena_t* const tensor_arena = tensor_init_states->tensor_arena;

  ccv_nnc_tensor_t* const output_tensor = ccv_nnc_tensor_from_symbol(tensor_arena, output_symbol);

  if (!output_tensor)

    return;

  const int d = output_symbol.d;

  assert(d < tensor_init_states->compiled_data->tensors_init.size);

  uint32_t* const init_v = CCV_NNC_INIT_V(tensor_init_states->compiled_data->tensors_init.v);

  if (init_v[d >> 5] & (1u << (d & 0x1f)))

    return;

  init_v[d >> 5] |= (1u << (d & 0x1f));

  ccv_nnc_cmd_exec(cmd, hint, flags, &input, input ? 
112
 : 
0288
, &output_tensor, 1, 0);

  const ccv_nnc_symbolic_graph_t* const graph = tensor_init_states->graph;

  const int parallel_count = tensor_init_states->parallel_count;

  int i;

  for (i = 1; i < parallel_count; 
i++480
)

  {

    ccv_nnc_tensor_t* const copy = ccv_nnc_tensor_from_symbol(tensor_arena, ccv_nnc_tensor_symbol_copy(graph, output_symbol, i));

    if (copy)

      ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, &output_tensor, 1, &copy, 1, 0);

  }

}

// This method can only handle cases we added new tensors and exec, never delete. This invariant is true because

// we setup everything (including calling simplify method) in ccv_cnnp_model_compile method, before this rewind setup.

static void _ccv_cnnp_model_rewind_graph(ccv_cnnp_model_t* const model)

{

  assert(model->graph);

  assert(model->compiled_data);

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  assert(compiled_data->rewindables);

  int i;

  for (i = 0; i < compiled_data->rewindables->rnum; 
i++49
)

  {

    const ccv_cnnp_rewind_symbol_t* const rewind_symbol = (ccv_cnnp_rewind_symbol_t*)ccv_array_get(compiled_data->rewindables, i);

    if (rewind_symbol->type == CCV_CNNP_REWIND_GRAPH_EXEC)

      ccv_nnc_graph_exec_symbol_free(model->graph, rewind_symbol->graph_exec);

    else if (rewind_symbol->type == CCV_CNNP_REWIND_TENSOR)

      ccv_nnc_tensor_symbol_free(model->graph, rewind_symbol->tensor);

  }

  ccv_array_clear(compiled_data->rewindables);

  ccv_nnc_graph_exec_symbol_autogen(model->graph, 0, 0, CCV_NNC_AUTOGEN_SOURCES_AND_DESTINATIONS);

}

static void _ccv_cnnp_model_tensor_symbol_new_hook(void* context, const ccv_nnc_tensor_symbol_t symbol, const ccv_nnc_tensor_param_t info, const char* const name)

{

  const ccv_cnnp_rewind_symbol_t rewind_symbol = {

    .type = CCV_CNNP_REWIND_TENSOR,

    .tensor = symbol

  };

  ccv_array_t* const rewind_symbols = (ccv_array_t*)context;

  ccv_array_push(rewind_symbols, &rewind_symbol);

}

static void _ccv_cnnp_model_tensor_symbol_alias_new_hook(void* context, const ccv_nnc_tensor_symbol_t symbol, const ccv_nnc_tensor_symbol_t from_symbol, const int ofs[CCV_NNC_MAX_DIM_ALLOC], const int inc[CCV_NNC_MAX_DIM_ALLOC], const ccv_nnc_tensor_param_t info, const char* const name)

{

  const ccv_cnnp_rewind_symbol_t rewind_symbol = {

    .type = CCV_CNNP_REWIND_TENSOR,

    .tensor = symbol

  };

  ccv_array_t* const rewind_symbols = (ccv_array_t*)context;

  ccv_array_push(rewind_symbols, &rewind_symbol);

}

static void _ccv_cnnp_model_graph_exec_symbol_new_hook(void* context, const ccv_nnc_graph_exec_symbol_t symbol, const ccv_nnc_cmd_t cmd, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, const ccv_nnc_tensor_symbol_t* const outputs, const int output_size, const char* const name)

{

  const ccv_cnnp_rewind_symbol_t rewind_symbol = {

    .type = CCV_CNNP_REWIND_GRAPH_EXEC,

    .graph_exec = symbol

  };

  ccv_array_t* const rewind_symbols = (ccv_array_t*)context;

  ccv_array_push(rewind_symbols, &rewind_symbol);

}

static void _ccv_cnnp_model_graph_symbol_exec_set_for_graph_exec_arena(const ccv_nnc_graph_exec_arena_t* const graph_exec_arena, const int parallel_count, const ccv_nnc_graph_exec_symbol_t exec_symbol, const ccv_nnc_cmd_t cmd, ccv_nnc_symbolic_graph_t* const symbolic_graph)

{

  ccv_nnc_graph_exec_t const update_exec = ccv_nnc_graph_exec_from_symbol(graph_exec_arena, exec_symbol);

  if (!CCV_NO_GRAPH_EXEC(update_exec))

    ccv_nnc_graph_exec_set(update_exec.graph, update_exec, cmd);

  int i;

  for (i = 1; i < parallel_count; 
i++14.8k
)

  {

    ccv_nnc_graph_exec_symbol_t copy_symbol = ccv_nnc_graph_exec_symbol_copy(symbolic_graph, exec_symbol, i);

    const ccv_nnc_graph_exec_t copy = ccv_nnc_graph_exec_from_symbol(graph_exec_arena, copy_symbol);

    if (!CCV_NO_GRAPH_EXEC(copy))

      ccv_nnc_graph_exec_set(copy.graph, copy, cmd);

  }

}

static void _ccv_cnnp_model_graph_exec_symbol_set(ccv_nnc_symbolic_graph_t* const symbolic_graph, ccv_cnnp_compiled_data_t* const compiled_data, const int parallel_count, const ccv_nnc_graph_exec_symbol_t exec_symbol, const ccv_nnc_cmd_t cmd)

{

  assert(compiled_data);

  assert(symbolic_graph);

  ccv_nnc_graph_exec_symbol_set(symbolic_graph, exec_symbol, cmd);

  int i;

  for (i = 1; i < parallel_count; 
i++14.9k
)

  {

    ccv_nnc_graph_exec_symbol_t copy_symbol = ccv_nnc_graph_exec_symbol_copy(symbolic_graph, exec_symbol, i);

    if (copy_symbol.graph)

      ccv_nnc_graph_exec_symbol_set(symbolic_graph, copy_symbol, cmd);

  }

  ccv_nnc_graph_exec_arena_t* const graph_exec_arena = compiled_data->graph_exec_arena;

  if (graph_exec_arena)

    _ccv_cnnp_model_graph_symbol_exec_set_for_graph_exec_arena(graph_exec_arena, parallel_count, exec_symbol, cmd, symbolic_graph);

  // Skip backward graph exec arena because it is for a specific accum symbolic graph, not the main graph (model->graph)

  ccv_nnc_graph_exec_arena_t* const gradient_graph_exec_arena = compiled_data->apply_gradients.graph_exec_arena;

  if (gradient_graph_exec_arena)

    _ccv_cnnp_model_graph_symbol_exec_set_for_graph_exec_arena(gradient_graph_exec_arena, parallel_count, exec_symbol, cmd, symbolic_graph);

}

static int _ccv_cnnp_set_minimizer_for_parameter(ccv_nnc_symbolic_graph_t* const graph, ccv_cnnp_compiled_data_t* const compiled_data, ccv_nnc_graph_exec_symbol_t* const update_nodes, ccv_nnc_tensor_symbol_t* const updated_parameters, ccv_nnc_tensor_symbol_map_t* const saved_aux, const int parallel_count, const ccv_nnc_cmd_t minimizer, const int saved_aux_size, const int max_saved_aux_size, const int parameter_indice)

{

  int this_parameter_flag = 0;

  if (update_nodes[parameter_indice].d == CCV_NNC_NO_TENSOR_SYMBOL)

    return this_parameter_flag;

  const ccv_nnc_cmd_t old_minimizer = ccv_nnc_graph_exec_symbol_cmd(graph, update_nodes[parameter_indice]);

  int j, k;

  // For no-op, we can preserve previous saved_aux_size.

  if (old_minimizer.cmd != minimizer.cmd && 
minimizer.cmd != CCV_NNC_NOOP71
)

  {

    // If the old minimizer is a noop, then the old_saved_aux_size should be whatever its previous

    // saved_aux_size is, otherwise we will reinit the saved_aux repeatedly if you switch between

    // noop and a minimizer. We don't want that because we do that in high-level frameworks to

    // make sure some model parameters don't update if we don't want them to.

    int old_saved_aux_size;

    if (old_minimizer.cmd == CCV_NNC_NOOP)

    {

      int input_size;

      ccv_nnc_graph_exec_symbol_io(graph, update_nodes[parameter_indice], 0, &input_size, 0, 0);

      if (input_size < 2) // This is not legit.

        old_saved_aux_size = ccv_nnc_minimizer_saved_aux_size(old_minimizer);

      else // See ccv_nnc_minimizer_saved_aux_size, the saved_aux is inputs excluding gradients and parameters.

        old_saved_aux_size = input_size - 2;

    } else

      old_saved_aux_size = ccv_nnc_minimizer_saved_aux_size(old_minimizer);

    if (old_saved_aux_size != saved_aux_size)

    {

      this_parameter_flag = 1;

      if (saved_aux_size > old_saved_aux_size)

      {

        // Allocate new tensor symbols.

        const ccv_nnc_tensor_param_t info = ccv_nnc_tensor_symbol_params(graph, updated_parameters[parameter_indice]);

        for (j = old_saved_aux_size; j < saved_aux_size; 
j++124
)

        {

          saved_aux[parameter_indice * max_saved_aux_size + j].source = ccv_nnc_tensor_symbol_new(graph, info, 0);

          saved_aux[parameter_indice * max_saved_aux_size + j].destination = ccv_nnc_tensor_symbol_new(graph, info, 0);

          const int device_id = CCV_TENSOR_GET_DEVICE_ID(info.type);

          for (k = 1; k < parallel_count; 
k++336
)

          {

            ccv_nnc_tensor_param_t dev_info = info;

            if (k != device_id)

              CCV_TENSOR_SET_DEVICE_ID(dev_info.type, k);

            else

              CCV_TENSOR_SET_DEVICE_ID(dev_info.type, 0);

            const ccv_nnc_tensor_symbol_t src_copy = ccv_nnc_tensor_symbol_new(graph, dev_info, 0);

            const ccv_nnc_tensor_symbol_t dest_copy = ccv_nnc_tensor_symbol_new(graph, dev_info, 0);

            ccv_nnc_tensor_symbol_set_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].source, k, src_copy);

            ccv_nnc_tensor_symbol_set_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].destination, k, dest_copy);

          }

        }

      } else {

        for (j = saved_aux_size; j < old_saved_aux_size; j++)

        {

          for (k = 1; k < parallel_count; k++)

          {

            const ccv_nnc_tensor_symbol_t src_copy = ccv_nnc_tensor_symbol_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].source, k);

            if (src_copy.d >= 0)

            {

              ccv_nnc_tensor_symbol_free(graph, src_copy);

              ccv_nnc_tensor_symbol_set_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].source, k, NO_TENSOR_SYMBOL);

            }

            const ccv_nnc_tensor_symbol_t dest_copy = ccv_nnc_tensor_symbol_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].destination, k);

            if (dest_copy.d >= 0)

            {

              ccv_nnc_tensor_symbol_free(graph, dest_copy);

              ccv_nnc_tensor_symbol_set_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].destination, k, NO_TENSOR_SYMBOL);

            }

          }

          ccv_nnc_tensor_symbol_free(graph, saved_aux[parameter_indice * max_saved_aux_size + j].source);

          ccv_nnc_tensor_symbol_free(graph, saved_aux[parameter_indice * max_saved_aux_size + j].destination);

          saved_aux[parameter_indice * max_saved_aux_size + j].source = saved_aux[parameter_indice * max_saved_aux_size + j].destination = NO_TENSOR_SYMBOL;

        }

      }

    }

  }

  _ccv_cnnp_model_graph_exec_symbol_set(graph, compiled_data, parallel_count, update_nodes[parameter_indice], minimizer);

  if (this_parameter_flag)

  {

    ccv_nnc_tensor_symbol_t update_inputs[saved_aux_size + 2];

    ccv_nnc_tensor_symbol_t update_outputs[saved_aux_size + 1];

    const int* inputs = 0;

    int input_size = 0;

    ccv_nnc_graph_exec_symbol_io(graph, update_nodes[parameter_indice], &inputs, &input_size, 0, 0);

    assert(input_size >= 1);

    update_inputs[0].d = inputs[0];

    update_inputs[0].graph = graph;

    update_inputs[1].d = inputs[1];

    update_inputs[1].graph = graph;

    update_outputs[0] = updated_parameters[parameter_indice];

    for (j = 0; j < saved_aux_size; 
j++124
)

    {

      update_inputs[j + 2] = saved_aux[parameter_indice * max_saved_aux_size + j].source;

      update_outputs[j + 1] = saved_aux[parameter_indice * max_saved_aux_size + j].destination;

    }

    ccv_nnc_graph_exec_symbol_set_io(graph, update_nodes[parameter_indice], update_inputs, saved_aux_size + 2, update_outputs, saved_aux_size + 1);

    for (k = 1; k < parallel_count; 
k++168
)

    {

      const ccv_nnc_graph_exec_symbol_t copy = ccv_nnc_graph_exec_symbol_copy(graph, update_nodes[parameter_indice], k);

      assert(copy.d >= 0);

      ccv_nnc_graph_exec_symbol_io(graph, copy, &inputs, &input_size, 0, 0);

      assert(input_size >= 1);

      update_inputs[0].d = inputs[0];

      update_inputs[0].graph = graph;

      update_inputs[1].d = inputs[1];

      update_inputs[1].graph = graph;

      update_outputs[0] = ccv_nnc_tensor_symbol_copy(graph, updated_parameters[parameter_indice], k);

      for (j = 0; j < saved_aux_size; 
j++336
)

      {

        update_inputs[j + 2] = ccv_nnc_tensor_symbol_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].source, k);

        update_outputs[j + 1] = ccv_nnc_tensor_symbol_copy(graph, saved_aux[parameter_indice * max_saved_aux_size + j].destination, k);

      }

      ccv_nnc_graph_exec_symbol_set_io(graph, copy, update_inputs, saved_aux_size + 2, update_outputs, saved_aux_size + 1);

    }

  }

  return this_parameter_flag;

}

typedef struct {

  int parameter_size;

  ccv_nnc_cmd_t minimizer;

  ccv_cnnp_model_io_t parameters[1];

} ccv_cnnp_set_minimizer_for_parameter_t;

static int _ccv_cnnp_apply_parameters_with_minimizer(ccv_cnnp_model_t* const model)

{

  ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;

  assert(compiled_data);

  const int max_saved_aux_size = compiled_data->minimize.max_saved_aux_size;

  // We update all parameters, at this point, we have one minimizer.

  const int parameter_size = compiled_data->parameters->rnum;

  ccv_nnc_graph_exec_symbol_t* const update_nodes = compiled_data->update_nodes;

  ccv_nnc_symbolic_graph_t* const symbolic_graph = model->graph;

  assert(symbolic_graph);

  const int parallel_count = ccv_max(model->parallel_count, 1);

  ccv_array_t* const parameters = compiled_data->minimize.parameters;

  ccv_array_t* const parameter_indices = ccv_array_new(sizeof(int), 0, 0);

  int i, j, flag = 0;

  for (i = 0; i < parameters->rnum; 
i++5
)

  {

    ccv_cnnp_set_minimizer_for_parameter_t* const set_minimizer_for_parameter = *(ccv_cnnp_set_minimizer_for_parameter_t**)ccv_array_get(parameters, i);

    for (j = 0; j < set_minimizer_for_parameter->parameter_size; 
j++5
)

    {

      const int param_sel = set_minimizer_for_parameter->parameters[j]->param_sel > 0 ? 
set_minimizer_for_parameter->parameters[j]->param_sel - 13
 : 
set_minimizer_for_parameter->parameters[j]->param_sel2
;

      assert(set_minimizer_for_parameter->parameters[j]->param_sel != 0);

      const int old_rnum = parameter_indices->rnum;

      ccv_cnnp_model_add_to_parameter_indices(set_minimizer_for_parameter->parameters[j]->model, param_sel, parameter_indices);

      const int param_ref = set_minimizer_for_parameter->parameters[j]->param_ref > 0 ? 
set_minimizer_for_parameter->parameters[j]->param_ref - 10
 : set_minimizer_for_parameter->parameters[j]->param_ref;

      assert(set_minimizer_for_parameter->parameters[j]->param_ref != 0);

      if (param_ref >= 0)

      {

        assert(param_ref + old_rnum < parameter_indices->rnum);

        *(int*)ccv_array_get(parameter_indices, old_rnum) = *(int*)ccv_array_get(parameter_indices, param_ref + old_rnum);

        parameter_indices->rnum = old_rnum + 1;

      }

    }

    const int saved_aux_size = ccv_nnc_minimizer_saved_aux_size(set_minimizer_for_parameter->minimizer);

    // We may have duplicated indices, but that is OK, we will set it twice.

    for (j = 0; j < parameter_indices->rnum; 
j++53
)

    {

      const int d = *(int*)ccv_array_get(parameter_indices, j);

      assert(d <= parameter_size);