#include "ccv_nnc.h"

#include "ccv_nnc_easy.h"

#include "ccv_nnc_internal.h"

#include "ccv_internal.h"

#include "_ccv_nnc_graph.h"

// MARK - Level-2 API

ccv_nnc_graph_t* ccv_nnc_graph_new(void)

{

  ccv_nnc_graph_t* graph = (ccv_nnc_graph_t*)cccalloc(1, sizeof(ccv_nnc_graph_t));

  graph->exec_info = ccv_array_new(sizeof(ccv_nnc_graph_exec_info_t), 5, 0);

  return graph;

}

void ccv_nnc_graph_set_sources(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t* const sources, const int source_size)

{

  if (!graph->sources)

    graph->sources = ccv_array_new(sizeof(ccv_nnc_graph_exec_t), source_size, 0);

  else

    ccv_array_clear(graph->sources);

  int i;

  for (i = 0; i < source_size; 
i++6.23k
)

    ccv_array_push(graph->sources, sources + i);

  graph->topsorted = 0;

}

ccv_nnc_graph_exec_t* ccv_nnc_graph_sources(const ccv_nnc_graph_t* const graph)

{

  return graph->sources ? (ccv_nnc_graph_exec_t*)ccv_array_get(graph->sources, 0) : 0;

}

int ccv_nnc_graph_source_size(const ccv_nnc_graph_t* const graph)

{

  return graph->sources ? graph->sources->rnum : 0;

}

void ccv_nnc_graph_set_destinations(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t* const destinations, const int destination_size)

{

  if (!graph->destinations)

    graph->destinations = ccv_array_new(sizeof(ccv_nnc_graph_exec_t), destination_size, 0);

  else

    ccv_array_clear(graph->sources);

  int i;

  for (i = 0; i < destination_size; 
i++6.23k
)

    ccv_array_push(graph->destinations, destinations + i);

  graph->topsorted = 0;

}

ccv_nnc_graph_exec_t* ccv_nnc_graph_destinations(const ccv_nnc_graph_t* const graph)

{

  return graph->destinations ? (ccv_nnc_graph_exec_t*)ccv_array_get(graph->destinations, 0) : 0;

}

int ccv_nnc_graph_destination_size(const ccv_nnc_graph_t* const graph)

{

  return graph->destinations ? graph->destinations->rnum : 0;

}

void ccv_nnc_graph_exec_set(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec, const ccv_nnc_cmd_t cmd)

{

  assert(exec.d < graph->exec_info->rnum);

  assert(exec.graph == graph);

  ccv_nnc_graph_exec_info_t* const exec_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  exec_info->cmd = cmd;

}

ccv_nnc_cmd_t ccv_nnc_graph_exec_cmd(const ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec)

{

  assert(exec.d < graph->exec_info->rnum);

  assert(exec.graph == graph);

  ccv_nnc_graph_exec_info_t* const exec_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  return exec_info->cmd;

}

void ccv_nnc_graph_exec_set_hint(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec, const ccv_nnc_hint_t hint)

{

  assert(exec.d < graph->exec_info->rnum);

  assert(exec.graph == graph);

  ccv_nnc_graph_exec_info_t* const exec_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  exec_info->hint = hint;

}

static int _ccv_nnc_tensor_multiview_level_count(const ccv_nnc_tensor_multiview_t* const mv)

{

  if (!CCV_IS_TENSOR_MULTIVIEW(mv))

    return 1;

  const int count = mv->kind + mv->repeat;

  int i, c = 0;

  for (i = 0; i < count; 
i++347
)

  {

    ccv_nnc_tensor_t* tv = CCV_NNC_MULTIVIEW_DATA(mv)[i];

    if (tv == CCV_NNC_TENSOR_PLACEHOLDER)

      c = ccv_max(c, 1);

    else

      c = ccv_max(c, _ccv_nnc_tensor_multiview_level_count((ccv_nnc_tensor_multiview_t*)tv));

  }

  return c + 1;

}

static ccv_nnc_graph_tensor_wrap_t* _ccv_nnc_graph_tensor_wrap_new(const ccv_nnc_tensor_multiview_t* const mv)

{

  const int level_count = _ccv_nnc_tensor_multiview_level_count(mv);

  ccv_nnc_graph_tensor_wrap_t* tensor_wrap = (ccv_nnc_graph_tensor_wrap_t*)ccmalloc(sizeof(ccv_nnc_graph_tensor_wrap_t) + sizeof(ccv_nnc_tensor_t*) * (level_count - 1));

  tensor_wrap->update_required = 0;

  tensor_wrap->count = level_count;

  tensor_wrap->index = 0;

  tensor_wrap->tensors[0] = (ccv_nnc_tensor_t*)mv;

  return tensor_wrap;

}

static void _ccv_nnc_graph_exec_rewind(ccv_nnc_graph_exec_info_t* const info, ccv_nnc_graph_t* const graph)

{

  if (!info->tensor_wraps_ref)

    return;

  int i;

  assert(info->tensor_wraps_ref <= graph->tensor_wraps->rnum);

  ccv_nnc_graph_tensor_wrap_array_t* const tensor_wrap_array = *(ccv_nnc_graph_tensor_wrap_array_t**)ccv_array_get(graph->tensor_wraps, info->tensor_wraps_ref - 1);;

  // Rewind from tensor wraps.

  for (i = 0; i < info->input_size; 
i++2
)

    if (tensor_wrap_array->tensor_wraps[i])

      info->inputs[i] = tensor_wrap_array->tensor_wraps[i]->tensors[0];

  const int d = info->input_size;

  for (i = 0; i < info->output_size; 
i++1
)

    if (tensor_wrap_array->tensor_wraps[d + i])

      info->outputs[i] = tensor_wrap_array->tensor_wraps[d + i]->tensors[0];

  const int dd = info->input_size + info->output_size;

  for (i = 0; i < info->update_size; 
i++0
)

    if (tensor_wrap_array->tensor_wraps[dd + i])

      info->updates[i] = tensor_wrap_array->tensor_wraps[dd + i]->tensors[0];

}

static void _ccv_nnc_graph_tensor_wrap_free(ccv_nnc_graph_tensor_wrap_t* const tensor_wrap)

{

  ccfree(tensor_wrap);

}

ccv_nnc_graph_tensor_wrap_array_t* ccv_nnc_get_tensor_wrap_array(ccv_nnc_graph_t* const graph, const int tensor_wrap_size, int* const tensor_wraps_ref)

{

  ccv_nnc_graph_tensor_wrap_array_t** tensor_wrap_array_ref = *tensor_wraps_ref ? 
(ccv_nnc_graph_tensor_wrap_array_t**)9
ccv_array_get9
(graph->tensor_wraps, *tensor_wraps_ref - 1) : 
053
;

  // Otherwise, find an open slot.

  if (!tensor_wrap_array_ref)

  {

    if (!graph->tensor_wraps)

      graph->tensor_wraps = ccv_array_new(sizeof(ccv_nnc_graph_tensor_wrap_array_t*), 0, 0);

    ccv_nnc_graph_tensor_wrap_array_t* const tensor_wrap_array = 0;

    ccv_array_push(graph->tensor_wraps, &tensor_wrap_array);

    tensor_wrap_array_ref = (ccv_nnc_graph_tensor_wrap_array_t**)ccv_array_get(graph->tensor_wraps, graph->tensor_wraps->rnum - 1);

    *tensor_wraps_ref = graph->tensor_wraps->rnum;

  }

  int i;

  if (*tensor_wrap_array_ref)

  {

    if ((*tensor_wrap_array_ref)->size != tensor_wrap_size)

      *tensor_wrap_array_ref = (ccv_nnc_graph_tensor_wrap_array_t*)ccrealloc(*tensor_wrap_array_ref, sizeof(ccv_nnc_graph_tensor_wrap_array_t) + sizeof(ccv_nnc_graph_tensor_wrap_t*) * (tensor_wrap_size - 1));

    for (i = (*tensor_wrap_array_ref)->size; i < tensor_wrap_size; 
i++9
)

      (*tensor_wrap_array_ref)->tensor_wraps[i] = 0;

  } else

    *tensor_wrap_array_ref = (ccv_nnc_graph_tensor_wrap_array_t*)cccalloc(sizeof(ccv_nnc_graph_tensor_wrap_array_t) + sizeof(ccv_nnc_graph_tensor_wrap_t*) * (tensor_wrap_size - 1), 1);

  ccv_nnc_graph_tensor_wrap_array_t* const tensor_wrap_array = *tensor_wrap_array_ref;

  tensor_wrap_array->size = tensor_wrap_size;

  return tensor_wrap_array;

}

void ccv_nnc_set_tensor_wraps(ccv_nnc_graph_tensor_wrap_t** const tensor_wraps, ccv_nnc_tensor_t* const* const tensors, const int tensor_size)

{

  int i;

  for (i = 0; i < tensor_size; 
i++165
)

    if (tensors[i])

    {

      if (CCV_IS_TENSOR_MULTIVIEW(tensors[i]) &&

        
((ccv_nnc_tensor_multiview_t*)tensors[i])->anchor != 111
CCV_NNC_MULTIVIEW_PHI111
)

      {

        if (!tensor_wraps[i] || 
tensors[i] != tensor_wraps[i]->tensors[0]14
)

        {

          if (tensor_wraps[i])

            _ccv_nnc_graph_tensor_wrap_free(tensor_wraps[i]);

          tensor_wraps[i] = _ccv_nnc_graph_tensor_wrap_new((ccv_nnc_tensor_multiview_t*)tensors[i]);

        }

      } else {

        if (tensor_wraps[i])

          _ccv_nnc_graph_tensor_wrap_free(tensor_wraps[i]);

        tensor_wraps[i] = 0;

      }

    }

}

void ccv_nnc_graph_register_tensor_wraps(ccv_nnc_graph_t* graph, const int tensor_wraps_ref_d)

{

  ccv_nnc_graph_t* p = graph;

  const ccv_nnc_graph_tensor_wraps_ref_t tensor_wraps_ref = {

    .d = tensor_wraps_ref_d,

    .graph = graph,

  };

  do {

    if (!p->tensor_wraps_refs)

    {

      p->tensor_wraps_refs = ccv_array_new(sizeof(ccv_nnc_graph_tensor_wraps_ref_t), 0, 0);

      ccv_array_push(p->tensor_wraps_refs, &tensor_wraps_ref);

    } else {

      int i;

      int has_tensor_wraps_ref = 0;

      for (i = 0; !has_tensor_wraps_ref && i < p->tensor_wraps_refs->rnum; 
i++97
)

      {

        ccv_nnc_graph_tensor_wraps_ref_t* tensor_wraps_ref = (ccv_nnc_graph_tensor_wraps_ref_t*)ccv_array_get(p->tensor_wraps_refs, i);

        has_tensor_wraps_ref = (tensor_wraps_ref->d == tensor_wraps_ref_d && 
tensor_wraps_ref->graph == graph8
);

      }

      if (!has_tensor_wraps_ref)

        ccv_array_push(p->tensor_wraps_refs, &tensor_wraps_ref);

    }

    p = p->p;

  } while (p);

}

static void _ccv_nnc_graph_redo_tensor_wraps(ccv_nnc_graph_exec_info_t* const info, ccv_nnc_graph_t* const graph)

{

  int i;

  const int has_wrap = ccv_nnc_tensors_have_wraps(info->inputs, info->input_size) ||

    
ccv_nnc_tensors_have_wraps(info->outputs, info->output_size)32.4k
 ||

    
ccv_nnc_tensors_have_wraps(info->updates, info->update_size)32.4k
;

  if (has_wrap)

  {

    const int tensor_wrap_size = info->input_size + info->output_size + info->update_size;

    ccv_nnc_graph_tensor_wrap_array_t* const tensor_wrap_array = ccv_nnc_get_tensor_wrap_array(graph, tensor_wrap_size, &info->tensor_wraps_ref);

    ccv_nnc_set_tensor_wraps(tensor_wrap_array->tensor_wraps, info->inputs, info->input_size);

    const int d = info->input_size;

    ccv_nnc_set_tensor_wraps(tensor_wrap_array->tensor_wraps + d, info->outputs, info->output_size);

    const int dd = info->input_size + info->output_size;

    ccv_nnc_set_tensor_wraps(tensor_wrap_array->tensor_wraps + dd, info->updates, info->update_size);

  } else if (info->tensor_wraps_ref) {

    ccv_nnc_graph_tensor_wrap_array_t** tensor_wrap_array_ref = (ccv_nnc_graph_tensor_wrap_array_t**)ccv_array_get(graph->tensor_wraps, info->tensor_wraps_ref - 1);

    ccv_nnc_graph_tensor_wrap_array_t* const tensor_wrap_array = *tensor_wrap_array_ref;

    if (tensor_wrap_array)

    {

      for (i = 0; i < tensor_wrap_array->size; 
i++3
)

        if (tensor_wrap_array->tensor_wraps[i])

          _ccv_nnc_graph_tensor_wrap_free(tensor_wrap_array->tensor_wraps[i]);

      ccfree(tensor_wrap_array);

      *tensor_wrap_array_ref = 0;

      info->tensor_wraps_ref = 0;

    }

  }

}

static void _ccv_nnc_graph_deregister_tensor_wraps(ccv_nnc_graph_t* graph, const int tensor_wraps_ref_d)

{

  ccv_nnc_graph_t* p = graph;

  do {

    int i;

    // Remove from the array.

    if (p->tensor_wraps_refs)

      for (i = 0; i < p->tensor_wraps_refs->rnum; 
i++0
)

      {

        ccv_nnc_graph_tensor_wraps_ref_t* const tensor_wraps_ref = (ccv_nnc_graph_tensor_wraps_ref_t*)ccv_array_get(p->tensor_wraps_refs, i);

        if (tensor_wraps_ref->d == tensor_wraps_ref_d && tensor_wraps_ref->graph == graph)

        {

          --p->tensor_wraps_refs->rnum;

          if (i < p->tensor_wraps_refs->rnum)

            memcpy(tensor_wraps_ref, tensor_wraps_ref + 1, sizeof(ccv_nnc_graph_exec_t) * (p->tensor_wraps_refs->rnum - i));

          break;

        }

      }

    p = p->p;

  } while (p);

}

void ccv_nnc_graph_exec_set_io_flags(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec, const int* const input_flags, const int input_flag_size, const int* const output_flags, const int output_flag_size)

{

  assert(exec.d < graph->exec_info->rnum);

  assert(exec.graph == graph);

  ccv_nnc_graph_exec_info_t* const info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  assert(input_flag_size <= info->input_size);

  assert(output_flag_size <= info->output_size);

  if (info->input_size + info->output_size == 0)

    return;

  if (!info->input_flags)

  {

    info->input_flags = (int*)cccalloc(info->input_size + info->output_size, sizeof(int));

    info->output_flags = info->input_flags + info->input_size;

  }

  if (input_flag_size > 0)

    memcpy(info->input_flags, input_flags, sizeof(int) * input_flag_size);

  if (output_flag_size > 0)

    memcpy(info->output_flags, output_flags, sizeof(int) * output_flag_size);

}

void ccv_nnc_graph_exec_pair_with(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec, const ccv_nnc_graph_exec_t pair_exec)

{

  assert(exec.graph == graph);

  assert(exec.d >= 0);

  assert(exec.d < graph->exec_info->rnum);

  assert(pair_exec.graph == graph || pair_exec.graph == graph->pair);

  assert(pair_exec.d >= 0);

  if (pair_exec.graph == graph)

    { assert(pair_exec.d < graph->exec_info->rnum); }

  else

    { assert(pair_exec.d < graph->pair->exec_info->rnum); }

  ccv_nnc_graph_exec_info_t* const exec_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  exec_info->pair_ref = pair_exec.d + 1;

}

static ccv_nnc_tensor_t* _ccv_nnc_any_tensor_from_tensor_multiview(ccv_nnc_tensor_multiview_t* const mv)

{

  ccv_nnc_tensor_t* tensor = (ccv_nnc_tensor_t*)mv;

  while (CCV_IS_TENSOR_MULTIVIEW(tensor))

  {

    ccv_nnc_tensor_multiview_t* mv = (ccv_nnc_tensor_multiview_t*)tensor;

    const int count = 0;

    const int off = mv->kind;

    const int mod = mv->repeat;

    // If reached the root.

    tensor = CCV_NNC_MULTIVIEW_DATA(mv)[count >= off ? 
((count - off) % mod) + off83
 : 
count13
]; // Unwrap.

  }

  return tensor;

}

void ccv_nnc_graph_exec_set_io(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size)

{

  assert(exec.d < graph->exec_info->rnum);

  assert(exec.graph == graph);

  ccv_nnc_graph_exec_info_t* const info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  // De-register from the graph if it contains multiview tensors.

  if (info->tensor_wraps_ref)

    _ccv_nnc_graph_deregister_tensor_wraps(graph, info->tensor_wraps_ref - 1);

  // In case it is already executed, rewind.

  _ccv_nnc_graph_exec_rewind(info, graph);

  if (input_size == 0 && 
output_size == 04
)

  {

    if (info->input_size > 0 || info->output_size > 0)

      ccfree(info->inputs);

    info->inputs = 0;

    info->outputs = 0;

    info->input_size = 0;

    info->output_size = 0;

    _ccv_nnc_graph_redo_tensor_wraps(info, graph);

    if (info->tensor_wraps_ref)

      ccv_nnc_graph_register_tensor_wraps(graph, info->tensor_wraps_ref - 1);

    return;

  }

  if (info->inputs)

    info->inputs = (ccv_nnc_tensor_t**)ccrealloc(info->inputs, sizeof(ccv_nnc_tensor_t*) * (input_size + output_size));

  else

    info->inputs = (ccv_nnc_tensor_t**)ccmalloc(sizeof(ccv_nnc_tensor_t*) * (input_size + output_size));

  info->outputs = info->inputs + input_size;

  if (inputs)

    memcpy(info->inputs, inputs, sizeof(ccv_nnc_tensor_t*) * input_size);

  if (outputs)

    memcpy(info->outputs, outputs, sizeof(ccv_nnc_tensor_t*) * output_size);

  int i;

  int tensor_memory = 0, tensor_formats = 0, tensor_datatypes = 0;

  for (i = 0; i < input_size + output_size; 
i++55
)

    if (info->inputs[i])

    {

      ccv_nnc_tensor_t* const tensor = CCV_IS_TENSOR_MULTIVIEW(info->inputs[i]) ? 
_ccv_nnc_any_tensor_from_tensor_multiview((ccv_nnc_tensor_multiview_t*)info->inputs[i])3
 : 
info->inputs[i]52
;

      tensor_memory |= CCV_TENSOR_GET_MEMORY(tensor->info.type), tensor_formats |= tensor->info.format, tensor_datatypes |= CCV_GET_DATA_TYPE(tensor->info.datatype);

    }

  info->cmd.backend = ccv_nnc_cmd_find_backend(info->cmd, tensor_memory, tensor_formats, tensor_datatypes);

  info->input_size = input_size;

  info->output_size = output_size;

  _ccv_nnc_graph_redo_tensor_wraps(info, graph);

  // Register again if the tensor wraps exist.

  if (info->tensor_wraps_ref)

    ccv_nnc_graph_register_tensor_wraps(graph, info->tensor_wraps_ref - 1);

  // Free flags.

  if (info->input_flags)

  {

    ccfree(info->input_flags);

    info->input_flags = info->output_flags = 0;

  }

}

void ccv_nnc_graph_exec_add_as_affected(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t exec, ccv_nnc_tensor_t* const update)

{

  assert(CCV_IS_TENSOR_MULTIVIEW(update));

  assert(exec.d < graph->exec_info->rnum);

  assert(exec.graph == graph);

  ccv_nnc_graph_exec_info_t* const info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, exec.d);

  const int register_tensor_wraps = !info->tensor_wraps_ref;

  const int update_index = info->update_size;

  ++info->update_size;

  if (info->updates)

    info->updates = (ccv_nnc_tensor_t**)ccrealloc(info->updates, sizeof(ccv_nnc_tensor_t*) * info->update_size);

  else

    info->updates = (ccv_nnc_tensor_t**)ccmalloc(sizeof(ccv_nnc_tensor_t*) * info->update_size);

  info->updates[update_index] = update;

  _ccv_nnc_graph_redo_tensor_wraps(info, graph);

  if (register_tensor_wraps)

    ccv_nnc_graph_register_tensor_wraps(graph, info->tensor_wraps_ref - 1);

}

ccv_nnc_graph_exec_t ccv_nnc_graph_exec_new(ccv_nnc_graph_t* const graph, const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size)

{

  int d = graph->exec_info->rnum;

  ccv_nnc_graph_exec_info_t info = {

    .cmd = cmd,

    .hint = hint,

    .input_size = input_size,

    .output_size = output_size,

  };

  assert(inputs || input_size == 0);

  assert(outputs || output_size == 0);

  if (input_size > 0 || 
output_size > 04.71k
)

  {

    info.inputs = (ccv_nnc_tensor_t**)ccmalloc(sizeof(ccv_nnc_tensor_t*) * (input_size + output_size));

    info.outputs = info.inputs + input_size;

    if (inputs)

      memcpy(info.inputs, inputs, sizeof(ccv_nnc_tensor_t*) * input_size);

    if (outputs)

      memcpy(info.outputs, outputs, sizeof(ccv_nnc_tensor_t*) * output_size);

    info.input_size = input_size;

    info.output_size = output_size;

    int i;

    int tensor_memory = 0, tensor_formats = 0, tensor_datatypes = 0;

    for (i = 0; i < input_size + output_size; 
i++141k
)

      if (info.inputs[i])

      {

        ccv_nnc_tensor_t* const tensor = CCV_IS_TENSOR_MULTIVIEW(info.inputs[i]) ? 
_ccv_nnc_any_tensor_from_tensor_multiview((ccv_nnc_tensor_multiview_t*)info.inputs[i])76
 : 
info.inputs[i]105k
;

        tensor_memory |= CCV_TENSOR_GET_MEMORY(tensor->info.type), tensor_formats |= tensor->info.format, tensor_datatypes |= CCV_GET_DATA_TYPE(tensor->info.datatype);

      }

    info.cmd.backend = ccv_nnc_cmd_find_backend(info.cmd, tensor_memory, tensor_formats, tensor_datatypes);

  }

  _ccv_nnc_graph_redo_tensor_wraps(&info, graph);

  // Add itself to the graph's wraps array, this will help the run time when we run the graph and do unwrapping.

  if (info.tensor_wraps_ref)

    ccv_nnc_graph_register_tensor_wraps(graph, info.tensor_wraps_ref - 1);

  ccv_array_push(graph->exec_info, &info);

  return (ccv_nnc_graph_exec_t){

    .d = d,

    .graph = graph,

  };

}

void ccv_nnc_graph_add_carry_over(ccv_nnc_graph_t* const graph, const ccv_nnc_tensor_t* const from, const ccv_nnc_tensor_t* const to)

{

  ccv_nnc_graph_tensor_carry_over_t carry_over = {

    .from = _ccv_nnc_graph_tensor_wrap_new((ccv_nnc_tensor_multiview_t*)from),

    .to = _ccv_nnc_graph_tensor_wrap_new((ccv_nnc_tensor_multiview_t*)to)

  };

  if (!graph->carry_overs)

    graph->carry_overs = ccv_array_new(sizeof(ccv_nnc_graph_tensor_carry_over_t), 0, 0);

  ccv_array_push(graph->carry_overs, &carry_over);

}

int ccv_nnc_graph_exec_concat(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t source, const ccv_nnc_graph_exec_t destination)

{

  assert(graph == source.graph);

  assert(graph == destination.graph);

  assert(source.d < graph->exec_info->rnum);

  assert(destination.d < graph->exec_info->rnum);

  ccv_nnc_graph_exec_info_t* src_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, source.d);

  if (src_info->outgoings == 0)

    src_info->outgoings = ccv_array_new(sizeof(int32_t), 1, 0);

  else {

    int i;

    // Check if this is already connected, if so, skip.

    for (i = 0; i < src_info->outgoings->rnum; 
i++6.24k
)

      if (*(int*)ccv_array_get(src_info->outgoings, i) == destination.d)

        return -1;

  }

  ccv_array_push(src_info->outgoings, &destination.d);

  graph->topsorted = 0;

  return 0;

}

int ccv_nnc_graph_exec_disjoin(ccv_nnc_graph_t* const graph, const ccv_nnc_graph_exec_t source, const ccv_nnc_graph_exec_t destination)

{

  assert(graph == source.graph);

  assert(graph == destination.graph);

  assert(source.d < graph->exec_info->rnum);

  assert(destination.d < graph->exec_info->rnum);

  ccv_nnc_graph_exec_info_t* src_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, source.d);

  if (!src_info->outgoings)

    return -1;

  int i;

  // Check if this is already connected, if so, skip.

  for (i = 0; i < src_info->outgoings->rnum; i++)

    if (*(int*)ccv_array_get(src_info->outgoings, i) == destination.d)

    {

      if (i < src_info->outgoings->rnum - 1)

        *(int*)ccv_array_get(src_info->outgoings, i) = *(int*)ccv_array_get(src_info->outgoings, src_info->outgoings->rnum - 1);

      --src_info->outgoings->rnum;

      graph->topsorted = 0;

      return 0;

    }

  return -1;

}

int ccv_nnc_graph_exec_count(const ccv_nnc_graph_t* const graph)

{

  return graph->exec_info ? graph->exec_info->rnum : 0;

}

void* ccv_nnc_graph_buffer(ccv_nnc_graph_t* const graph, int size)

{

  if (graph->buffer_size >= size)

    return graph->buffer;

  graph->buffer_size = size;

  graph->buffer = (graph->buffer) ? 
ccrealloc17
(graph->buffer, size)17
 : 
ccmalloc335
(size)335
;

  return graph->buffer;

}

void ccv_nnc_graph_topsort(ccv_nnc_graph_t* const graph, int* const exec_cvt, const int exec_cvt_size)

{

  if (exec_cvt_size == 0 && 
graph->exec_info->rnum == 00
)

  {

    graph->topsorted = 1;

    return;

  }

  assert(exec_cvt_size == graph->exec_info->rnum);

  assert(graph->sources && graph->sources->rnum);

  assert(graph->destinations && graph->destinations->rnum);

  int i, j;

  for (i = 0; i < exec_cvt_size; 
i++32.4k
)

    exec_cvt[i] = -1;

  ccv_array_t* exec_info = ccv_array_new(sizeof(ccv_nnc_graph_exec_info_t), graph->exec_info->rnum, 0);

  // If there are breakpoints, it is more complicated, we first start to the breakpoints, and then continue from the breakpoints to the destinations.

  if (graph->breakpoint_size)

  {

    ccv_nnc_graph_visit_t* visit = 
ccv_nnc_graph_visit_new21
(graph, (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0), graph->exec_info->rnum, (ccv_nnc_graph_exec_t*)ccv_array_get(graph->sources, 0), graph->sources->rnum, graph->breakpoints, graph->breakpoint_size, 0);

    for (i = 0; i < graph->breakpoint_size; 
i++21
)

      exec_cvt[graph->breakpoints[i].d] = -2; // Mark this as breakpoints, so we will skip the first round.

    
ccv_nnc_graph_visit_for32
(visit, (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0), node, idx) {

      assert(!node->pair_ref); // If node has a pair ref, we cannot fix it up.

      if (exec_cvt[idx] == -2) // Skip breakpoint.

        continue;

      // Loop over node and push to the array.

      ccv_array_push(exec_info, node);

      // Go to its sub-graph to fix exec_idx

      for (i = 0; i < node->graph_ref_size; 
i++0
)

      {

        const int graph_ref = CCV_NNC_GRAPH_REF(node)[i] - 1;

        if (graph_ref >= 0)

        {

          ccv_nnc_graph_t* const sub_graph = *(ccv_nnc_graph_t**)ccv_array_get(graph->sub_graphs, graph_ref);

          sub_graph->exec_idx = exec_info->rnum;

        }

      }

      exec_cvt[idx] = exec_info->rnum - 1;

    } ccv_nnc_graph_visit_endfor

    ccv_nnc_graph_visit_free(visit);

    graph->breakpoint_offset = exec_info->rnum;

    visit = 
ccv_nnc_graph_visit_new21
(graph, (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0), graph->exec_info->rnum, graph->breakpoints, graph->breakpoint_size, (ccv_nnc_graph_exec_t*)ccv_array_get(graph->destinations, 0), graph->destinations->rnum, 0);

    ccv_nnc_graph_visit_for(visit, (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0), node, idx) {

      assert(!node->pair_ref); // If node has a pair ref, we cannot fix it up.

      // Loop over node and push to the array.

      ccv_array_push(exec_info, node);

      // Go to its sub-graph to fix exec_idx

      for (i = 0; i < node->graph_ref_size; 
i++8
)

      {

        const int graph_ref = CCV_NNC_GRAPH_REF(node)[i] - 1;

        if (graph_ref >= 0)

        {

          ccv_nnc_graph_t* const sub_graph = *(ccv_nnc_graph_t**)ccv_array_get(graph->sub_graphs, graph_ref);

          sub_graph->exec_idx = exec_info->rnum;

        }

      }

      exec_cvt[idx] = exec_info->rnum - 1;

    } ccv_nnc_graph_visit_endfor

    ccv_nnc_graph_visit_free(visit);

    for (i = 0; i < graph->breakpoint_size; 
i++21
)

      { assert(exec_cvt[graph->breakpoints[i].d] >= 0); } // All breakpoints should be assigned.

  } else {

    ccv_nnc_graph_visit_t* visit = 
ccv_nnc_graph_visit_new6.20k
(graph, (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0), graph->exec_info->rnum, (ccv_nnc_graph_exec_t*)ccv_array_get(graph->sources, 0), graph->sources->rnum, (ccv_nnc_graph_exec_t*)ccv_array_get(graph->destinations, 0), graph->destinations->rnum, 0);

    ccv_nnc_graph_visit_for(visit, (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0), node, idx) {

      assert(!node->pair_ref); // If node has a pair ref, we cannot fix it up.

      // Loop over node and push to the array.

      ccv_array_push(exec_info, node);

      // Go to its sub-graph to fix exec_idx

      for (i = 0; i < node->graph_ref_size; 
i++42
)

      {

        const int graph_ref = CCV_NNC_GRAPH_REF(node)[i] - 1;

        if (graph_ref >= 0)

        {

          ccv_nnc_graph_t* const sub_graph = *(ccv_nnc_graph_t**)ccv_array_get(graph->sub_graphs, graph_ref);

          sub_graph->exec_idx = exec_info->rnum;

        }

      }

      exec_cvt[idx] = exec_info->rnum - 1;

    } ccv_nnc_graph_visit_endfor

    ccv_nnc_graph_visit_free(visit);

  }

  assert(graph->exec_info->rnum == exec_info->rnum);

  ccv_array_free(graph->exec_info);

  graph->exec_info = exec_info;

  for (i = 0; i < graph->sources->rnum; 
i++6.22k
)

  {

    ccv_nnc_graph_exec_t* const source = (ccv_nnc_graph_exec_t*)ccv_array_get(graph->sources, i);

    source->d = exec_cvt[source->d];

  }

  for (i = 0; i < graph->destinations->rnum; 
i++6.22k
)

  {

    ccv_nnc_graph_exec_t* const destination = (ccv_nnc_graph_exec_t*)ccv_array_get(graph->destinations, i);

    destination->d = exec_cvt[destination->d];

  }

  // Update all outgoings to reflect the latest.

  for (i = 0; i < exec_info->rnum; 
i++32.4k
)

  {

    ccv_nnc_graph_exec_info_t* const info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(exec_info, i);

    if (info->outgoings)

      
for (j = 0; 26.1k
j < info->outgoings->rnum; 
j++29.2k
)

        *(int*)ccv_array_get(info->outgoings, j) = exec_cvt[*(int*)ccv_array_get(info->outgoings, j)];

  }

  graph->topsorted = 1;

}

typedef struct {

  int device_id;

  int exec_idx;

  ccv_array_t* signal_set;

  ccv_array_t* command_set; // The set of command executed in this stream. In case there is a tie (on rank). We will check this.

} ccv_nnc_stream_data_t;

static void _ccv_nnc_graph_schedule_assign_signals(ccv_array_t* const incoming, ccv_nnc_graph_exec_schedule_t* const node, ccv_array_t* const stream_data, int* const signal_size, ccv_nnc_graph_exec_schedule_t* const exec_info, const int exec_info_size)

{

  assert(incoming->rnum > 0);

  int i, j, k;

  int wait_size = 0, max_wait_size = 0;

  for (i = 0; i < incoming->rnum; 
i++5.98k
)

  {

    const int incoming_idx = *(int*)ccv_array_get(incoming, i);

    ccv_nnc_graph_exec_schedule_t* const incoming_exec_info = exec_info + incoming_idx;

    assert(incoming_exec_info->stream_size > 0);

    max_wait_size += incoming_exec_info->stream_size;

  }

  int waits[ccv_max(1, max_wait_size)];

  assert(node->stream_size > 0);

  
for (i = 0; 4.80k
i < incoming->rnum; 
i++5.98k
)

  {

    const int incoming_idx = *(int*)ccv_array_get(incoming, i);

    assert(incoming_idx < exec_info_size);

    assert(incoming_idx >= 0);

    ccv_nnc_graph_exec_schedule_t* const incoming_exec_info = exec_info + incoming_idx;

    assert(incoming_exec_info->stream_size > 0);

    int stream_synced = 1;

    // If the current node's stream is a subset of the incoming node's stream, there

    // is no need to sync with signal, because we are already synced with the incoming.

    for (j = 0; stream_synced && 
j < node->stream_size10.2k
; 
j++5.99k
)

    {

      const int s = SCHEDULE_STREAMS(*node)[j];

      assert(s >= 0);

      int flag = 0;

      for (k = 0; !flag && 
k < incoming_exec_info->stream_size8.55k
; 
k++6.82k
)

        flag = (SCHEDULE_STREAMS(*incoming_exec_info)[k] == s);

      stream_synced = flag;

    }

    if (stream_synced)

      continue;

    // Otherwise, find the streams we need to sync with, and create signals for these.

    
for (j = 0; 1.73k
j < incoming_exec_info->stream_size; 
j++1.75k
)

    {

      const int s = SCHEDULE_STREAMS(*incoming_exec_info)[j];

      assert(s >= 0);

      int flag = 0;

      for (k = 0; !flag && 
k < node->stream_size4.48k
; 
k++2.75k
)

        flag = (SCHEDULE_STREAMS(*node)[k] == s);

      if (!flag) // Need to have a signal.

      {

        if (SCHEDULE_SIGNALS(*incoming_exec_info)[j] < 0)

          SCHEDULE_SIGNALS(*incoming_exec_info)[j] = (*signal_size)++;

        else {

          int flag = 0;

          // If any of the stream the current node has already seen this signal, we are good already.

          for (k = 0; !flag && k < node->stream_size; 
k++943
)

          {

            assert(SCHEDULE_STREAMS(*node)[k] >= 0);

            ccv_nnc_stream_data_t* const data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, SCHEDULE_STREAMS(*node)[k]);

            flag = (data->signal_set && 
ccv_array_find_int(data->signal_set, 427
SCHEDULE_SIGNALS427
(*incoming_exec_info)[j]));

          }

          if (flag)

            continue;

        }

        // Otherwise, we need to wait for this. Currently, our granularity is about wait on all streams.

        waits[wait_size++] = SCHEDULE_SIGNALS(*incoming_exec_info)[j];

        // All streams on this node have seen this signal.

        for (k = 0; k < node->stream_size; 
k++2.70k
)

        {

          ccv_nnc_stream_data_t* const data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, SCHEDULE_STREAMS(*node)[k]);

          if (!data->signal_set)

            data->signal_set = ccv_array_new(sizeof(int), 0, 0);

          ccv_array_push(data->signal_set, &SCHEDULE_SIGNALS(*incoming_exec_info)[j]);

        }

      }

    }

  }

  node->wait_size = wait_size;

  if (wait_size > 0)

  {

    node->waits = node->waits ? 
ccrealloc0
(node->waits, sizeof(int) * wait_size)0
 : ccmalloc(sizeof(int) * wait_size);

    memcpy(node->waits, waits, sizeof(int) * wait_size);

  }

}

typedef struct {

  int rank;

  ccv_array_t* outgoings;

} ccv_nnc_incoming_t;

static int _ccv_nnc_device_ids_for_stream_data(ccv_nnc_graph_exec_info_t* const node, const int device_id, ccv_array_t* const stream_data, int* const device_ids, const int max_device_id_size)

{

  // TODO: I need to re-think whether this is GPU only or not.

  int device_id_size = ccv_nnc_device_ids_for_io(node->inputs, node->input_size, node->outputs, node->output_size, CCV_TENSOR_GPU_MEMORY, device_ids, max_device_id_size);

  if (device_id_size == 0)

  {

    // If there is a default data, use that device id. Otherwise, use the device id passed in (this will be the default data device id).

    if (stream_data->rnum > 0)

    {

      ccv_nnc_stream_data_t* const default_data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, 0);

      device_ids[0] = default_data->device_id;

    } else

      device_ids[0] = device_id >= 0 ? 
device_id2
 : 
0178
;

    device_id_size = 1;

  }

  return device_id_size;

}

void ccv_nnc_graph_static_schedule_free(ccv_nnc_graph_static_schedule_t* const schedule)

{

  int i;

  ccv_nnc_graph_exec_schedule_t* const schd_info = schedule->exec_info;

  for (i = 0; i < schedule->exec_info_size; 
i++7.24k
)

  {

    if (schd_info[i].stream_size > 1)

      ccfree(schd_info[i]._heap_streams);

    if (schd_info[i].waits)

      ccfree(schd_info[i].waits);

  }

  if (schedule->stream_1s)

    ccfree(schedule->stream_1s);

  if (schedule->waits)

    ccfree(schedule->waits);

  if (schedule->psort)

    ccfree(schedule->psort);

  if (schedule->begin)

    ccv_nnc_stream_signal_free(schedule->begin);

  if (schedule->end)

    ccv_nnc_stream_signal_free(schedule->end);

  ccfree(schedule);

}

static ccv_nnc_graph_static_schedule_t* _ccv_nnc_graph_static_schedule_new(ccv_nnc_graph_t* const graph, const int stream_type, const int device_id, const int max_stream_count, ccv_nnc_stream_context_t* const stream_context, const ccv_nnc_graph_exec_t* const _sources, const int _source_size, const ccv_nnc_graph_exec_t* const _destinations, const int _destination_size)

{

  assert(graph->sources && graph->sources->rnum);

  assert(graph->destinations && graph->destinations->rnum);

  assert(graph->topsorted); // Only support this on a topsorted graph.

  const int exec_info_size = graph->exec_info->rnum;

  assert(exec_info_size > 0);

  const ccv_nnc_graph_exec_t* const sources = _sources == 0 ? 
(ccv_nnc_graph_exec_t*)371
ccv_array_get371
(graph->sources, 0) : 
_sources29
;

  const int source_size = _sources == 0 ? 
graph->sources->rnum371
 : 
_source_size29
;

  if (!_sources)

    { assert(_source_size == 0); }

  const ccv_nnc_graph_exec_t* const destinations = _destinations == 0 ? 
(ccv_nnc_graph_exec_t*)362
ccv_array_get362
(graph->destinations, 0) : 
_destinations38
;

  const int destination_size = _destinations == 0 ? 
graph->destinations->rnum362
 : 
_destination_size38
;

  if (!_destinations)

    { assert(_destination_size == 0); }

  const int root_schedule = (_sources == 0 && 
_destinations == 0371
);

  ccv_nnc_graph_static_schedule_t* const schedule = cccalloc(1, sizeof(ccv_nnc_graph_static_schedule_t) + sizeof(ccv_nnc_graph_exec_schedule_t) * (exec_info_size - 1));

  schedule->exec_info_size = exec_info_size;

  ccv_nnc_graph_exec_schedule_t* const schd_info = schedule->exec_info;

  ccv_nnc_graph_exec_info_t* const exec_info = (ccv_nnc_graph_exec_info_t*)ccv_array_get(graph->exec_info, 0);

  ccv_nnc_graph_visit_t* visit = 
ccv_nnc_graph_visit_new400
(graph, exec_info, exec_info_size, sources, source_size, destinations, destination_size, 0);

  if (!root_schedule)

  {

    // If this is not a root schedule, we need to do partial topsort.

    int psort_size = 0;

    ccv_nnc_graph_visit_for(visit, exec_info, node, idx) {

      ++psort_size;

    } ccv_nnc_graph_visit_endfor

    schedule->psort = (int*)ccmalloc(sizeof(int) * psort_size);

    schedule->psort_size = psort_size;

    psort_size = 0;

    ccv_nnc_graph_visit_for(visit, exec_info, node, idx) {

      schedule->psort[psort_size++] = idx;

    } ccv_nnc_graph_visit_endfor

  }

  int i, j, k;

  // Generate exec dependencies (or, in other words, partial ordering of executions).

  ccv_sparse_matrix_t* exec_dep = ccv_sparse_matrix_new(exec_info_size, exec_info_size, CCV_32S | CCV_C1, CCV_SPARSE_ROW_MAJOR, 0);

  int* buf = (int*)
ccmalloc400
(sizeof(int) * exec_info_size * 2);

  int buf_size;

#define for_block(x, val) \

  do { \

    if (((int32_t*)val)[0] > 0) \

    { \

      buf[buf_size * 2] = x; \

      buf[buf_size * 2 + 1] = ((int32_t*)val)[0] + 1; \

      ++buf_size; \

    } \

  } while (0)

  for (i = 0; i < exec_info_size; 
i++7.24k
)

    schd_info[i].stream_size = -1;

  ccv_nnc_graph_visit_for(visit, exec_info, node, idx, term) {

    buf_size = 0; /* save all its parent deps to this buffer */

    ccv_sparse_matrix_vector_t* vector = ccv_get_sparse_matrix_vector(exec_dep, idx);

    schd_info[idx].stream_size = 0;

    if (vector)

      
CCV_SPARSE_VECTOR_FOREACH4.80k
(exec_dep, vector, for_block);

    if (!node->outgoings)

      continue;

    
for (i = 0; 4.85k
i < node->outgoings->rnum; 
i++9.21k
)

    {

      int outgoing = *(int*)ccv_array_get(node->outgoings, i);

      const int32_t one = 1;

      ccv_numeric_data_t cell = ccv_get_sparse_matrix_cell(exec_dep, outgoing, idx);

      /* If not found, set, if the current node is the destination node, no need

       * set itself as parent of subsequent nodes because its terminal nature. */

      if (!term && 
(9.13k
!cell.i329.13k
 || 
cell.i32[0] == 00
))

        ccv_set_sparse_matrix_cell(exec_dep, outgoing, idx, &one);

      for (j = 0; j < buf_size; 
j++300k
) /* set with all idx's dependencies as well */

      {

        ccv_numeric_data_t cell = ccv_get_sparse_matrix_cell(exec_dep, outgoing, buf[j * 2]);

        /* If not found, set */

        if (!cell.i32 || 
cell.i32[0] == 0117k
)

          ccv_set_sparse_matrix_cell(exec_dep, outgoing, buf[j * 2], &buf[j * 2 + 1]);

        else {

          /* Otherwise, set to the longest one */

          int32_t dep = ccv_max(cell.i32[0], buf[j * 2 + 1]);

          ccv_set_sparse_matrix_cell(exec_dep, outgoing, buf[j * 2], &dep);

        }

      }

    }

  } ccv_nnc_graph_visit_endfor

#undef for_block

  ccfree(buf);

  // Algorithm to allocate signals and streams for this graph.

  ccv_array_t* const stream_data = ccv_array_new(sizeof(ccv_nnc_stream_data_t), 0, 0);

  ccv_array_t** const outgoings = cccalloc(exec_info_size, sizeof(ccv_array_t*));

  ccv_nnc_incoming_t* const incomings = cccalloc(exec_info_size, sizeof(ccv_nnc_incoming_t));

  int max_device_id_size = 1;

  // Filter out outgoing nodes that we will be able to access it afterwards anyway.

  ccv_nnc_graph_visit_for(visit, exec_info, node, idx) {

    max_device_id_size = ccv_max(node->input_size + node->output_size, max_device_id_size);

    if (node->outgoings)

    {

      outgoings[idx] = ccv_array_new(sizeof(int), 0, 0);

      for (i = 0; i < node->outgoings->rnum; 
i++9.21k
)

      {

        const int di = *(int*)ccv_array_get(node->outgoings, i);

        // Skip if we haven't accessed this exec.

        if (schd_info[di].stream_size < 0)

          continue;

        int flag = 0;

        for (j = 0; !flag && 
j < node->outgoings->rnum24.3k
; 
j++18.3k
)

        {

          if (j != i)

          {

            const int dj = *(int*)ccv_array_get(node->outgoings, j);

            ccv_numeric_data_t cell = ccv_get_sparse_matrix_cell(exec_dep, di, dj);

            flag = (cell.i32 && 
cell.i32[0]1.88k
);

          }

        }

        if (!flag)

        {

          ccv_array_push(outgoings[idx], &di);

          if (!incomings[di].outgoings)

            incomings[di].outgoings = ccv_array_new(sizeof(int), 1, 0);

          ccv_array_push(incomings[di].outgoings, &idx);

        }

      }

    }

  } ccv_nnc_graph_visit_endfor

#define visitor(node, idx, _) \

  if (node->outgoings) \

    
for (i = 0; 4.80k
i < node->outgoings->rnum; 
i++5.98k
) \

    { \

      const int d = *(int*)ccv_array_get(node->outgoings, i); \

      node->rank = ccv_max(incomings[d].rank + 1, node->rank); \

    }

  
CCV_NNC_GRAPH_VISIT400
(graph, incomings, exec_info_size, destinations, destination_size, sources, source_size, 0, visitor);

#undef visitor

  int device_ids[max_device_id_size];

  int outgoing_device_ids[max_device_id_size];

  int signal_size = 0;

  ccv_nnc_graph_visit_for(visit, exec_info, node, idx) {

    // Go through the incomings.

    const int device_id_size = _ccv_nnc_device_ids_for_stream_data(node, device_id, stream_data, device_ids, max_device_id_size);

    if (schd_info[idx].stream_size == 0)

    {

      schd_info[idx].stream_size = device_id_size; // At least at the same size as the device_id_size.

      if (device_id_size > 1)

      {

        schd_info[idx]._heap_streams = (int*)ccmalloc(sizeof(int) * device_id_size * 2);

        schd_info[idx]._heap_signals = (schd_info[idx]._heap_streams + device_id_size);

      }

      for (i = 0; i < device_id_size; 
i++434
)

        SCHEDULE_STREAMS(schd_info[idx])[i] = -1, SCHEDULE_SIGNALS(schd_info[idx])[i] = -1;

    }

    for (i = 0; i < device_id_size; 
i++5.63k
)

      // Go through until the end to assign streams.

      if (SCHEDULE_STREAMS(schd_info[idx])[i] < 0)

      {

        int stream_idx = -1;

        int stream_has_command = 0;

        // First, find a good stream in stream data (the stream is good if it can be recycled, and it has the same command).

        // Otherwise, we prefer a usable stream (it doesn't have the command, but it can be recycled).

        for (j = 0; (stream_idx < 0 || 
!stream_has_command249
) && 
j < stream_data->rnum35.0k
; 
j++33.7k
)

        {

          ccv_nnc_stream_data_t* const data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, j);

          if (data->device_id == device_ids[i])

          {

            const ccv_numeric_data_t cell = ccv_get_sparse_matrix_cell(exec_dep, idx, data->exec_idx);

            // If there is a path to conclude that exec_idx is before idx, then we can reuse

            // this stream. Otherwise the work in this "empty stream" could still be ongoing,

            // and we may delay the following work unnecessarily.

            if (cell.i32 && 
cell.i32[0] > 0153
)

            {

              if (ccv_array_find_uint(data->command_set, node->cmd.cmd))

                stream_idx = j, stream_has_command = 1;

              else if (stream_idx < 0) // Otherwise, only assign the stream idx if it is not assigned yet.

                stream_idx = j;

            }

          }

        }

        if (stream_idx < 0)

        {

          // Note that the max stream count is a "soft" limit. Even we have different devices, our compute allocation has to be on different streams.

          if (stream_data->rnum >= max_stream_count && 
max_stream_count > 01.01k
)

          {

            // If we are already at out limit, go through again to see if a stream is available, if the stream has command, and also its exec_idx is not preceding this execution.

            for (j = 0; (stream_idx < 0 || !stream_has_command) && j < stream_data->rnum; j++)

            {

              ccv_nnc_stream_data_t* const data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, j);

              if (data->device_id == device_ids[i])

              {

                const ccv_numeric_data_t cell = ccv_get_sparse_matrix_cell(exec_dep, data->exec_idx, idx);

                // There must be no path from idx to exec_idx otherwise we already have stream_idx. Now we just to verify

                // there is no path from exec_idx to idx as well.

                if (!cell.i32 || cell.i32[0] == 0)

                {

                  if (ccv_array_find_uint(data->command_set, node->cmd.cmd))

                    stream_idx = j, stream_has_command = 1;

                  else if (stream_idx < 0) // Otherwise, only assign the stream idx if it is not assigned yet.

                    stream_idx = j;

                }

              }

            }

            if (stream_idx >= 0)

            {

              // Now need to mark exec_idx is after idx, so we can avoid A -> B -> A deadlock.

              ccv_nnc_stream_data_t* const data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, stream_idx);

              const int32_t one = 1;

              ccv_set_sparse_matrix_cell(exec_dep, idx, data->exec_idx, &one);

            }

          }

          if (stream_idx < 0)

          {

            stream_idx = stream_data->rnum;

            const ccv_nnc_stream_data_t data = {

              .device_id = device_ids[i],

            };

            ccv_array_push(stream_data, &data);

          }

        }

        assert(stream_idx >= 0);

        ccv_nnc_stream_data_t* const data = (ccv_nnc_stream_data_t*)ccv_array_get(stream_data, stream_idx);

        if (!data->command_set)

          data->command_set = ccv_array_new(sizeof(uint32_t), 1, 0);

        SCHEDULE_STREAMS(schd_info[idx])[i] = stream_idx;

        ccv_array_add_unique_uint(data->command_set, node->cmd.cmd);

        // Assign all subsequent node to use this stream.

        int outgoing_idx = idx;

        // if we want to enforce the stream count is only 1, we certainly don't want to the greedy approach.

        // With the greedy approach, the current stream will go all the way down and certainly conflict with

        // other streams. We'd prefer to interleaving the execution instead in this case.