Question about generating mechanism complexity (mcomplex.dat) for CORENEURON

[WeinaJi]

Hello all,

In the current simulation framework, the complexity per mechanism (mcomplex.dat) is generated via neuron ExperimentalMechComplex, e.g.

from neuron import h
pc = h.ParallelContext()
h.load_file("loadbal.hoc")
lb = h.LoadBalance()
lb.ExperimentalMechComplex()
pc.barrier()
h.quit()

where the values are calculated by the function/procedure:

func dorun() {
	xrun_ = $1
	if (execute1("xrun()", this) == 0) { return 1000 }
	return xrun_
}

proc xrun() {local tstop  localobj pc
	tstop = xrun_
	pc = new ParallelContext()
	finitialize(-70)
	xrun_ = pc.time
	batch_run(tstop, tstop)
	xrun_ = pc.time - xrun_
}

For CORENEURON simulator, the process is the same.
In order to achieve better load balancing for CORENEURON, is it possible to compute the mechanism complexities using CORENEURON? What kind of changes shall be done? In neuron code or at the user level ? Thanks!

[nrnhines]

At present none of that is implemented for CoreNEURON. Load balance presently is only possible
with file transfer mode between NEURON and CoreNEURON in which you specify for each file
which rank it is supposed to go on. Presently, I believe but am not certain, the files.dat file specifies
the rank of each file in a round-robin fashion. So load balance would imply permuting the
group gids in files.dat given a calculation (eg. in NEURON) of the complexity of each group gid.
That calculation is non-trivial since a mere summation of individual mechanism complexities is
likely a bad proxy for the expected computation time in CoreNEURON since memory latency and
bandwidth plays such a large role in the actual simulation time.

[pramodk]

Hello Michael,

Me, @iomaganaris and @WeinaJi were discussing this today morning. I vaguely remember details but what we (or I) was saying is that:

• neuron somewhere creates temporary section with X number of compartments and insert specific channel (or create synapses)
• then neuron run simulation by calling "psolve" or (similar function) and determine execution time
• based on these execution times, relative complexities for each mechanism is determined.
• and based on this mcomplex.dat is generated

Isn't there an easy way to replace "psolve" to "psolve_core" in this workflow as in-memory transfer is already working between neuron and coreneuron?

[nrnhines]

All your bullet points are correct. I just think that a scalar value for each mechanism, empty compartment, section, etc is insufficient for a CoreNeuron proxy and one cannot just multiply the
complexity of each element by the number of elements to get a good expectation of relative
computation time for each cell. (the list of proxy values for each cell along with the
total number of gid_groups (global number of threads) is used via a LeastProcessingTime algorithm to determine the cells in each gid_group.) If one does have a good proxy (some function of
element complexity and number of elements) then the construction of the NEURON model proceeds with that distribution and then it gets transferred to CoreNEURON and on the latter side everything
is balanced.