/*
* Emit JSON data with the peak memory usage of the current process.
*/
static void get_peak_memory_info(void)
{
DECLARE_PROC_ADDR(psapi.dll, BOOL, GetProcessMemoryInfo, HANDLE,
PPROCESS_MEMORY_COUNTERS, DWORD);
if (INIT_PROC_ADDR(GetProcessMemoryInfo)) {
PROCESS_MEMORY_COUNTERS pmc;
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc,
sizeof(pmc))) {
struct json_writer jw = JSON_WRITER_INIT;
jw_object_begin(&jw, 0);
#define KV(kv) #kv, (intmax_t)pmc.kv
jw_object_intmax(&jw, KV(PageFaultCount));
jw_object_intmax(&jw, KV(PeakWorkingSetSize));
jw_object_intmax(&jw, KV(PeakPagefileUsage));
jw_end(&jw);
trace2_data_json("process", the_repository,
"windows/memory", &jw);
jw_release(&jw);
}
}
}
static int
apecs_attach(device_t dev)
{
struct apecs_softc* sc = APECS_SOFTC(dev);
apecs_init();
/*
* the avanti routes interrupts through the isa interrupt
* controller, so we need to special case it
*/
if(hwrpb->rpb_type == ST_DEC_2100_A50)
chipset.intrdev = isa0;
else
chipset.intrdev = apecs0;
sc->dmem_base = APECS_PCI_DENSE;
sc->smem_base = APECS_PCI_SPARSE;
sc->io_base = APECS_PCI_SIO;
sc->cfg0_base = KV(APECS_PCI_CONF);
sc->cfg1_base = NULL;
set_iointr(alpha_dispatch_intr);
snprintf(chipset_type, sizeof(chipset_type), "apecs");
chipset_bwx = 0;
chipset_ports = APECS_PCI_SIO;
chipset_memory = APECS_PCI_SPARSE;
chipset_dense = APECS_PCI_DENSE;
chipset_hae_mask = EPIC_HAXR1_EADDR;
bus_generic_attach(dev);
return 0;
}
static void
apecs_swiz_writew(u_int32_t pa, u_int16_t data)
{
apecs_swiz_set_hae_mem(&pa);
SPARSE_WRITE_WORD(KV(APECS_PCI_SPARSE), pa, data);
alpha_wmb();
}
static u_int32_t
apecs_swiz_readl(u_int32_t pa)
{
alpha_mb();
apecs_swiz_set_hae_mem(&pa);
return SPARSE_READ_LONG(KV(APECS_PCI_SPARSE), pa);
}
static void
mcclock_tlsb_write(device_t dev, u_int reg, u_int val)
{
struct mcclock_tlsb_softc *sc = device_get_softc(dev);
unsigned char *ptr = (unsigned char *)
KV(sc->regbase + (reg << REGSHIFT));
*ptr = val;
}
static u_int
mcclock_tlsb_read(device_t dev, u_int reg)
{
struct mcclock_tlsb_softc *sc = device_get_softc(dev);
unsigned char *ptr = (unsigned char *)
KV(sc->regbase + (reg << REGSHIFT));
return *ptr;
}
static u_int
mcclock_tlsb_read(struct mc146818_softc *sc, u_int reg)
{
struct mcclock_tlsb_softc *tsc = (void *)sc;
unsigned char *ptr = (unsigned char *)
KV(tsc->regbase + (reg << REGSHIFT));
return *ptr;
}
static void
mcclock_tlsb_write(struct mc146818_softc *sc, u_int reg, u_int val)
{
struct mcclock_tlsb_softc *tsc = (void *)sc;
unsigned char *ptr = (unsigned char *)
KV(tsc->regbase + (reg << REGSHIFT));
*ptr = val;
}
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ibus_3max.c,v 1.15 2011/07/09 17:32:29 matt Exp $");
#include <sys/param.h>
#include <sys/device.h>
#include <sys/systm.h>
#include <dev/tc/tcvar.h>
#include <pmax/ibus/ibusvar.h>
#include <pmax/pmax/kn02.h>
static struct ibus_attach_args kn02sys_devs[] = {
{ "mc146818", SYS_DEV_BOGUS, KV(KN02_SYS_CLOCK), 0 },
{ "dc", SYS_DEV_SCC0, KV(KN02_SYS_DZ), 0 },
};
static int kn02sys_match(device_t, cfdata_t, void *);
static void kn02sys_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(kn02sys, 0,
kn02sys_match, kn02sys_attach, NULL, NULL);
static int
kn02sys_match(device_t parent, cfdata_t cf, void *aux)
{
struct tc_attach_args *ta = aux;
return (strncmp("KN02SYS ", ta->ta_modname, TC_ROM_LLEN) == 0);
int main(int argc, char **argv)
{
int world_size;
float dvalue = 0.0;
int flag_script;
int recvd_proc_rank;
int send_to_rank;
int procs_completed = 1;
int my_rank;
int loop_var;
int processors;
int n_steps = (int)time_max / dt;
char processor_name[MPI_MAX_PROCESSOR_NAME];
int name_length;
int current_trial;
int base_rank = 1;
int loop_ends = 0;
char *file_path = (char*)malloc(100*sizeof(char));
char *base_path = (char*)malloc(100*sizeof(char));
char *coupling_path = (char*)malloc(8*sizeof(char));
char *trial_path = (char*)malloc(8*sizeof(char));
double _FinalISI[10][100];
// _FinalISI = alloc_2d_float(10,100);
int _no_spikes[10][100];
// _no_spikes = alloc_2d_int(10,100);
double _connections[10][100];
// _connections = alloc_2d_double(10,100);
double _tot_degree[10][12];
// _tot_degree = alloc_2d_double(10,12);
int _count_degree[10][12];
// _count_degree = alloc_2d_int(10,12);
double *_firing_coherence = (double *)malloc(10*sizeof(double));
int *recvd_rank = (int *)malloc(10*sizeof(int));
int rec_proc_rank;
int i, j, l; //Looping variables. Not using k because it is already used
MPI_Init(&argc, &argv);
float dmin = strtof(argv[1], NULL);
float dmax = strtof(argv[2], NULL);
float dstep = strtof(argv[3], NULL);
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Get_processor_name(processor_name, &name_length);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// the scheduler process is mapped to the the first core of the first socket
if (my_rank == 0)
{
// printf("value of N is %d", N);
srand(time(NULL) + my_rank*world_size);
flag_script = system("nproc > processors.txt ");
if (flag_script)
{
fprintf(stderr, "Failed to launch script nproc > processors.txt\n");
return 1;
}
FILE *no_processors = fopen("processors.txt", "r");
fscanf(no_processors, "%d", &processors);
fclose(no_processors);
flag_script = system("rm processors.txt");
if (flag_script)
{
fprintf(stderr, "Failed to launch script rm processors.txt\n");
return 1;
}
///////////////////////////////check the condition////////////////////////////////////////////////////////////
for(loop_var = 0; loop_var < (3*processors)/11; loop_var++)
{
//using a synchronous send to different cores which correspond to coupling strength values
// in case of processors > processes, keep a check condition based on dmax
if (base_rank < world_size)
{
dvalue = dmin + loop_var*dstep;
MPI_Send(&dvalue, 1, MPI_FLOAT, base_rank, 0, MPI_COMM_WORLD);
base_rank+=11;
// procs_completed+=10;
}
}
while (1)
{
// Receive the rank of the process completed
MPI_Recv(&recvd_proc_rank,1,MPI_INT,MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
// printf("RECEIVED PROCESS %d\n", recvd_proc_rank);
if ((recvd_proc_rank-1)%11 == 0) // Safeguard to ensure that only the coupling process sends back data
{
procs_completed+=11; // or 11? Increment the number of completed
// printf("procs completed are %d\n",procs_completed);
if (procs_completed == world_size)
{
break;
}
if (base_rank < world_size) // Send the computed process to the free set of cores
{
// instead of changing the rankfile, find the process(es) which yields the same mapping to the cores
// as the coupling_strength process which completed, and launch it
dvalue = dmin + dstep*(base_rank/11);
// printf("Sending the dvalue %f with dmax as %f to %d\n", dvalue, dmax, base_rank);
MPI_Send(&dvalue, 1, MPI_FLOAT, base_rank, 0, MPI_COMM_WORLD);
// printf("SENT PROCESS %d\n", recvd_proc_rank);
base_rank+=11;
}
}
if ((recvd_proc_rank-1)%11 != 0 )
{
printf("ERROR ENCOUNTERED\n");
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// First thread section, associate each file pointer with a thread for initialisation
// Destroy threads and dynamic memory after allocation
// long thread = 0;
// int thread_count = 4;
// pthread_t *thread_handles;
// pthread_attr_t attr;
//
// thread_handles = malloc(thread_count*sizeof(pthread_t));
// pthread_attr_init(&attr);
//
// pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
//
// for (thread = 0; thread < thread_count; thread++)
// {
// pthread_create(&thread_handles[thread], &attr, declare_init_files, (void*) thread);
// }
//
// for(thread = 0; thread < thread_count; thread++)
// {
// pthread_join(thread_handles[thread], NULL);
// }
//
// free(thread_handles);
//End of first thread section
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// TO DO
// Compute a stringbuilder for the file paths
// Recieve all the variables and do the computations
// Write the values to the files
// Send the final computations to the coupling process
if ((my_rank-1)%11 == 0)
{
// printf("Rank is %d", my_rank);
srand(time(NULL) + my_rank*world_size);
// Recieve the coupling strength value from the scheduler process;
MPI_Recv(&dvalue, 1, MPI_FLOAT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
snprintf(coupling_path, 8, "%f", dvalue);
getcwd(file_path, 100);
strcat(file_path, "/");
strcat(file_path,coupling_path);
strcat(file_path, "/");
strcpy(base_path, file_path);
// This file stores the Firing Coherence values for various coupling strengths (D)
strcat(file_path, "FiringCoherenceVaryingDs(100,8)(0.9;0.6).txt");
firingcoherenceid = fopen(file_path, "w");
// This file stores the Firing Correlation values as a function of degree of separation
strcpy(file_path, base_path);
strcat(file_path, "FCDegreeVaryingD(100,8)(0.9;0.6).txt");
fcdegreeid = fopen(file_path, "w");
// This file stores the ISIs of induvidual neurons in the network
strcpy(file_path, base_path);
strcat(file_path, "ISI_no_connections(100,8)(0.9;0.6).txt");
fisiid = fopen(file_path, "w");
// This file stores the mean ISI of all the neurons in the network
strcpy(file_path, base_path);
strcat(file_path, "MeanISI(100,8)(0.9;0.6).txt");
fmeanisiid = fopen(file_path, "w");
// printf("D = %f\n", dvalue);
/*We are calculating the firing correlation as a function of degree in the network
* We are averaging our results over a number of variations in the network to reduce
* the effects of noise on the validity of our results.
* tot_degree is a variable which stores the firing correlation value over a particular degree of separation
* Over 'n' trials, we add up the values of firing correlation for one particular degree of separation in this
* and divide by the number of trials in which neurons are separated by those many number of hops
* count_degree stores the number of trials in which there exists a particular degree of separation
*/
for (i = 0; i < N; i++) // i ---> number of neurons
{
no_spikes[i] = 0;
FinalISI[i] = 0.0;
connections[i] = 0;
}
for (i = 0; i < 12; i++) // i ---> degree of separation
{
tot_degree[i] = 0;
count_degree[i] = 0;
}
// To send -
// Trial number to each core
// FinalISI over all the trials
// no_spikes over all the trials
// connections over all the trials
// count_degree over all the trials
// tot_degree over all the trials
// firing_coherence over all the trials
// trial / current_trial
for (send_to_rank = my_rank + 1, trial = 0; send_to_rank < my_rank + 11; send_to_rank++, trial++)
{
MPI_Send(&(FinalISI[0]), 100, MPI_DOUBLE, send_to_rank, 0, MPI_COMM_WORLD);
MPI_Send(&(no_spikes[0]), 100, MPI_INT, send_to_rank, 1, MPI_COMM_WORLD);
MPI_Send(&(connections[0]), 100, MPI_DOUBLE, send_to_rank, 2, MPI_COMM_WORLD);
MPI_Send(&tot_degree[0], 12, MPI_DOUBLE, send_to_rank, 3, MPI_COMM_WORLD);
MPI_Send(&count_degree[0], 12, MPI_INT, send_to_rank, 4, MPI_COMM_WORLD);
MPI_Send(&firing_coherence, 1, MPI_DOUBLE, send_to_rank, 5, MPI_COMM_WORLD);
MPI_Send(&my_rank, 1, MPI_INT, send_to_rank, 6, MPI_COMM_WORLD);
MPI_Send(&dvalue, 1, MPI_FLOAT, send_to_rank, 7, MPI_COMM_WORLD);
MPI_Send(&trial, 1, MPI_INT, send_to_rank, 8, MPI_COMM_WORLD);
}
// To recieve -
// FinalISI over all the trials
// no_spikes over all the trials
// connections over all the trials
// count_degree over all the trials
// tot_degree over all the trials
// firing_coherence over all the trials
for (i = 0; i < N; i++) // i ---> number of neurons
{
no_spikes[i] = 0;
FinalISI[i] = 0.0;
connections[i] = 0;
}
for (i = 0; i < 12; i++) // i ---> degree of separation
{
tot_degree[i] = 0;
count_degree[i] = 0;
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 100; i++)
{
_FinalISI[loop_var][i] = 0;
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 100; i++)
{
_no_spikes[loop_var][i] = 0;
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 100; i++)
{
_connections[loop_var][i] = 0;
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 12; i++)
{
_tot_degree[loop_var][i] = 0;
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 12; i++)
{
_count_degree[loop_var][i] = 0;
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
_firing_coherence[loop_var] = 0;
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
recvd_rank[loop_var] = 0;
}
for (send_to_rank = my_rank + 1, loop_var = 0; send_to_rank < my_rank + 11; send_to_rank++, loop_var++)
{
// MPI_Send(&(FinalISI[0]), 100, MPI_DOUBLE, recvd_proc_rank, 0, MPI_COMM_WORLD);
// MPI_Send(&(no_spikes[0]), 100, MPI_INT, recvd_proc_rank, 1, MPI_COMM_WORLD);
// MPI_Send(&(connections[0]), 100, MPI_DOUBLE, recvd_proc_rank, 2, MPI_COMM_WORLD);
// MPI_Send(&tot_degree[0], 12, MPI_DOUBLE, recvd_proc_rank, 3, MPI_COMM_WORLD);
// MPI_Send(&count_degree[0], 12, MPI_INT, recvd_proc_rank, 4, MPI_COMM_WORLD);
// MPI_Send(&firing_coherence, 1, MPI_DOUBLE, recvd_proc_rank, 5, MPI_COMM_WORLD);
// MPI_Send(&recvd_rank, 1, MPI_INT, recvd_proc_rank, 6, MPI_COMM_WORLD);
MPI_Recv(&(_FinalISI[loop_var][0]), 100, MPI_DOUBLE, send_to_rank, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&(_no_spikes[loop_var][0]), 100, MPI_INT, send_to_rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&(_connections[loop_var][0]), 100, MPI_DOUBLE, send_to_rank, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&_tot_degree[loop_var][0], 12, MPI_DOUBLE, send_to_rank, 3, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&_count_degree[loop_var][0], 12, MPI_INT, send_to_rank, 4, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&_firing_coherence[loop_var], 1, MPI_DOUBLE, send_to_rank, 5, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&recvd_rank[loop_var], 1, MPI_INT, send_to_rank, 6, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
if (isnan(_firing_coherence[loop_var]) == 0)
firing_coherence += _firing_coherence[loop_var];
}
// for (loop_var = 0; loop_var < 10; loop_var++)
// {
// for (i = 0; i < 100; i++)
// {
// printf("%f ",_connections[loop_var][i]);
// }
// printf("\n");
// }
firing_coherence/=10.0;
// printf("Firing Coherence = %f\n", firing_coherence);
fprintf(firingcoherenceid, "%f\t%f\n", dvalue, firing_coherence);
fprintf(fcdegreeid, "#D = %f\n", dvalue);
fprintf(fcdegreeid, "\n");
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 12; i++)
{
if (isnan(_tot_degree[loop_var][i]) == 0)
tot_degree[i]+=_tot_degree[loop_var][i];
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < 12; i++)
{
if (isnan(_count_degree[loop_var][i]) == 0)
count_degree[i]+=_count_degree[loop_var][i];
}
}
for (i = 0; i < 12; i++)
{
tot_degree[i] = tot_degree[i] / count_degree[i];
//fprintf(degreefcid, "%d\t%f\n",i+1,tot_degree[i]);
fprintf(fcdegreeid, "%d\t%f\n", i + 1, tot_degree[i]);
}
fprintf(fcdegreeid, "\n");
fprintf(fisiid, "#D = %f\n", dvalue);
double mean = 0.0;
double mean1 = 0.0;
double stddev = 0.0;
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < N; i++)
{
if (isnan(_FinalISI[loop_var][i]) == 0)
FinalISI[i]+=_FinalISI[loop_var][i];
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < N; i++)
{
if (isnan(_connections[loop_var][i]) == 0)
connections[i]+=_connections[loop_var][i];
}
}
for (loop_var = 0; loop_var < 10; loop_var++)
{
for (i = 0; i < N; i++)
{
if (isnan(_no_spikes[loop_var][i]) == 0)
no_spikes[i]+=_no_spikes[loop_var][i];
}
}
for (i = 0; i < N; i++)
{
FinalISI[i] = FinalISI[i] / 10.0;
mean = mean + FinalISI[i];
mean1 = mean1 + (FinalISI[i] * FinalISI[i]);
//connections[i] = connections[i]/2.0;
// FinalISI, connections averaged over all trials.
fprintf(fisiid, "%d\t %f\t %d\t %f\n", i + 1, connections[i], no_spikes[i], FinalISI[i]);
}
fprintf(fisiid, "\n");
mean = mean / N;
mean1 = mean1 / N;
stddev = sqrt(mean1 - (mean * mean));
fprintf(fmeanisiid, "#D = %f\n", dvalue);
fprintf(fmeanisiid, "Mean: %f\n", mean);
fprintf(fmeanisiid, "Standard Deviation: %f\n", stddev);
fprintf(fmeanisiid, "\n");
//fclose(degreefcid);
fclose(fcdegreeid);
fclose(firingcoherenceid);
fclose(fisiid);
fclose(fmeanisiid);
// Notify the scheduler that the process has completed
MPI_Send(&my_rank, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// TO DO
// Compute a stringbuilder for the file paths
// Recieve all the variables and do the computations
// Write the values to the files
// Send the final computations to the coupling process
if ((my_rank-1)%11 != 0 && my_rank!=0)
{
srand(time(NULL) + my_rank*world_size);
// add safeguards from the recieved process
// MPI_Send(&(FinalISI[0]), 100, MPI_DOUBLE, send_to_rank, 0, MPI_COMM_WORLD);
// MPI_Send(&(no_spikes[0]), 100, MPI_INT, send_to_rank, 1, MPI_COMM_WORLD);
// MPI_Send(&(connections[0]), 100, MPI_DOUBLE, send_to_rank, 2, MPI_COMM_WORLD);
// MPI_Send(&tot_degree[0], 12, MPI_DOUBLE, send_to_rank, 3, MPI_COMM_WORLD);
// MPI_Send(&count_degree[0], 12, MPI_INT, send_to_rank, 4, MPI_COMM_WORLD);
// MPI_Send(&firing_coherence, 1, MPI_DOUBLE, send_to_rank, 5, MPI_COMM_WORLD);
// MPI_Send(&my_rank, 1, MPI_INT, send_to_rank, 6, MPI_COMM_WORLD);
// MPI_Send(&dvalue, 1, MPI_FLOAT, send_to_rank, 7, MPI_COMM_WORLD);
// MPI_Send(&trial, 1, MPI_INT, send_to_rank, 8, MPI_COMM_WORLD);
MPI_Recv(&(FinalISI[0]), 100, MPI_DOUBLE, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&(no_spikes[0]), 100, MPI_INT, MPI_ANY_SOURCE, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&(connections[0]), 100, MPI_DOUBLE, MPI_ANY_SOURCE, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&tot_degree[0], 12, MPI_DOUBLE, MPI_ANY_SOURCE, 3, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&count_degree[0], 12, MPI_INT, MPI_ANY_SOURCE, 4, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&firing_coherence, 1, MPI_DOUBLE, MPI_ANY_SOURCE, 5, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&rec_proc_rank, 1, MPI_INT, MPI_ANY_SOURCE, 6, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(&dvalue, 1, MPI_FLOAT, MPI_ANY_SOURCE, 7, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(¤t_trial, 1, MPI_INT, MPI_ANY_SOURCE, 8, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
// printf("Rank is %d and trial number is %d and dvalue is %f\n", my_rank, current_trial + 1, dvalue);
getcwd(file_path, 100);
snprintf(coupling_path, 8, "%f", dvalue);
strcat(file_path, "/");
strcat(file_path,coupling_path);
strcat(file_path, "/");
sprintf(trial_path, "%d", current_trial);
strcat(file_path, trial_path);
strcat(file_path, "/");
strcpy(base_path, file_path);
strcat(file_path, "V_vs_T.txt");
fV_vs_t_id = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "Spiketime.txt");
fspiketimeid = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "Y.txt");
yid = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "VT.txt");
fVTid = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "RewiredMatrix.txt");
fAdjacencymatrixId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "Randomnumbers.txt");
frandomnumberId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "NoOfConnections.txt");
fNoConnectionsId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "m_noise.txt");
fm_noiseId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "mvalues.txt");
fmvalueId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "hvalues.txt");
fhvalueId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "nvalues.txt");
fnvalueId = fopen(file_path, "w");
strcpy(file_path, base_path);
strcat(file_path, "output.txt");
ftrial_output = fopen(file_path, "w");
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Second thread section, associate each file pointer with a thread for initialisation
// These files are used for computing values of ISI, firing coeffiecients etc. for each trial
// Files included are as follows -
// fV_vs_t_id => V_vs_T.txt
// fspiketimeid => Spiketime.txt
// yid => Y.txt
// fVTid => VT.txt
// fAdjacencymatrixId => RewiredMatrix.txt
// frandomnumberId => Randomnumbers.txt
// fNoConnectionsId => NoOfConnections.txt
// fm_noiseId => m_noise.txt
// fmvalueId => mvalues.txt
// fhvalueId => hvalues.txt
// fnvalueId => nvalues.txt
// Destroy threads and dynamic memory after allocation
// thread = 0;
// thread_count = 11;
// pthread_t *thread_handles;
// thread_handles = malloc(thread_count*sizeof(pthread_t));
//
// for (thread = 0; thread < thread_count; thread++)
// {
// pthread_create(&thread_handles[thread], &attr, declare_trial_files, (void*) thread);
// }
// associate each block of initialisation with a seperate thread
fprintf(ftrial_output, "p = %f\n", probability);
int Done = 0; //Flag
//Initializing degree array
for (i = 0; i < 20; i++)
{
degree[i] = 0;
}
//Initializing Edgematrix
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
edgematrix[i][j] = 0;
edgematrix1[i][j] = 0;
}
}
Nna = rhona * S;
Nk = rhok * S;
//Initializing V[j] Array
//Constructing a ring lattice with k/2 connections on either side of each node
for (i = 0; i < N; i++)
{
for (j = 1; j <= mean_degree/ 2; j++)
{
if ((i + j) >= N)
{
edgematrix[i][abs(N - (i + j))] = 1;
edgematrix[i][abs(i - j)] = 1;
edgematrix[abs(N - (i + j))][i] = 1; //Since for an undirectional graph, edgematrix[i][j] = edgematrix[j][i]
edgematrix[abs(i - j)][i] = 1;
}
else if ((i - j) < 0)
{
edgematrix[i][abs(N + (i - j))] = 1;
edgematrix[i][abs(i + j)] = 1;
edgematrix[abs(N + (i - j))][i] = 1; //Since for an undirectional graph, edgematrix[i][j] = edgematrix[j][i]
edgematrix[abs(i + j)][i] = 1;
}
else
{
edgematrix[i][abs(i + j)] = 1;
edgematrix[i][abs(i - j)] = 1;
edgematrix[abs(i + j)][i] = 1; //Since for an undirectional graph, edgematrix[i][j] = edgematrix[j][i]
edgematrix[abs(i - j)][i] = 1;
}
}
}
// for(thread = 0; thread < thread_count; thread++)
// {
// pthread_join(thread_handles[thread], NULL);
// }
//
// free(thread_handles);
//End of second thread section
///////////////////////////////////////////////////////////////////////////////////////////////////////////
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
fprintf(fAdjacencymatrixId, "%f ", edgematrix[i][j]);
edgematrix1[i][j] = edgematrix[i][j];
}
fprintf(fAdjacencymatrixId, "\n");
}
fprintf(fAdjacencymatrixId, "\n\n\n\n");
// Rewiring the system using the rewiring probability
fprintf(frandomnumberId, "#N = %d, k = %d, p = %f \n", nodes, mean_degree, probability);
fprintf(frandomnumberId, "S.No i j r re \n");
for (i = 0; i < N - 1; i++)
{
for (j = i + 1; j < N; j++)
{
if (edgematrix[i][j] == 1)
{
randomnumber = randomnumbergenerator(max_randomnumber); //Generate a random number and divide it by max_random number.
randomnumber = (float)randomnumber / (float)max_randomnumber; //If normalized value is less than p, remove connection
if (randomnumber < probability)
{
edgematrix[i][j] = 0;
edgematrix[j][i] = 0;
Done = 0;
while (Done != 1)
//Done is a flag variable. rewiringnumber stores the index of a random neuron in the network to which neuron 'i' gets rewired to.
//Self loops and redundant connections are avoided
//Hence, once we establish a connection which is not a self loop or a redundant connection, Done becomes 1 and we get out of the loop
{
rewiringnumber = randomnumbergenerator(N - 1);
if (rewiringnumber != i && edgematrix[i][rewiringnumber] == 0) //Eliminating self-loops & redundant connections
{
edgematrix[i][rewiringnumber] = 1;
edgematrix[rewiringnumber][i] = 1; //Since for an undirectional graph, edgematrix[i][j] = edgematrix[j][i]
fprintf(frandomnumberId, "%d %d %d %f %d\n", 0, i, j, randomnumber, rewiringnumber);
Done = 1;
}
else
{
continue;
}
}
}
}
else
continue;
}
//printf("Node %d rewired. \n", i+1);
}
//Writing into files and printing
//printf("Starting to write adjacency matrix into the file. \n\n");
fprintf(fAdjacencymatrixId, "#N = %d, k = %d, p = %f \n", nodes, mean_degree, probability);
fprintf(fNoConnectionsId, "#N = %d, k = %d, p = %f \n", nodes, mean_degree, probability);
for (i = 0; i < N; i++)
{
no_of_connections = 0;
for (j = 0; j < N; j++)
{
fprintf(fAdjacencymatrixId, "%f ", edgematrix[i][j]); //Printing Adjacency Matrix of neuron
if (edgematrix[i][j] == 1)
{
no_of_connections = no_of_connections + 1; //Calculating number of connections of current neuron
}
}
degree[no_of_connections]++;
connections[i] = connections[i] + no_of_connections;
fprintf(fAdjacencymatrixId, "\n");
fprintf(fNoConnectionsId, "%d %d\n", i + 1, no_of_connections);
}
//printf("Finished writing adjacency matrix into the file. \n\n");
//printf("Finished printing number of connections per neuron. \n\n");
for (i = 0; i < N; i++) // Iterating through all the nodes in the network
{
connections[i] = connections[i] / 2.0;
}
fprintf(fAdjacencymatrixId, "\n\n\n\n");
int countno = 0;
for (i = 0; i < N - 1; i++)
{
for (j = i + 1; j < N; j++)
{
if (edgematrix[i][j] == 0 && edgematrix1[i][j] == 1)
{
countno++;
}
}
}
fprintf(fAdjacencymatrixId, "%d", countno);
/*______________________________________________________________________________________________________________________________________*/
fprintf(ftrial_output, "No of time steps: %d\n", n_steps);
for (i = 0; i < N; i++)
{
V[i] = 0.0;
k1[i] = 0.0;
k2[i] = 0.0;
k3[i] = 0.0;
k4[i] = 0.0;
m1[i] = 0.0;
m2[i] = 0.0;
m3[i] = 0.0;
m4[i] = 0.0;
n1[i] = 0.0;
n2[i] = 0.0;
n3[i] = 0.0;
n4[i] = 0.0;
h1[i] = 0.0;
h2[i] = 0.0;
h3[i] = 0.0;
h4[i] = 0.0;
coupling1[i] = 0.0;
coupling2[i] = 0.0;
coupling3[i] = 0.0;
m_noise[i] = 0.0;
n_noise[i] = 0.0;
h_noise[i] = 0.0;
alpha_m[i] = (0.1 * (25 - V[i])) / (exp((25 - V[i]) / 10) - 1);
beta_m[i] = 4 * exp(-V[i] / 18);
alpha_h[i] = 0.07 * exp(-V[i] / 20);
beta_h[i] = 1 / (exp((30 - V[i]) / 10) + 1);
alpha_n[i] = 0.01 * (10 - V[i]) / (exp((10 - V[i]) / 10) - 1);
beta_n[i] = 0.125 * exp(-V[i] / 80);
/*alpha_m[i] = (0.1*(V[i] + 40))/(-exp((-40 - V[i])/10) + 1);
* beta_m[i] = 4*exp((-V[i] - 65)/18);
* alpha_h[i] = 0.07*exp((-V[i]-65)/20);
* beta_h[i] = 1/(exp((-35-V[i])/10) + 1);
* alpha_n[i] = 0.01*(V[i] + 55)/(-exp((-55-V[i])/10) + 1);
* beta_n[i] = 0.125*exp((-V[i]-65)/80);
*/
m[i] = (alpha_m[i] / (alpha_m[i] + beta_m[i]));
h[i] = (alpha_h[i] / (alpha_h[i] + beta_h[i]));
n[i] = (alpha_n[i] / (alpha_n[i] + beta_n[i]));
}
for (i = 0; i < N; i++)
{
sum_coupling = 0.0;
for (j = 0; j < N; j++)
{
sum_coupling = sum_coupling + (edgematrix[i][j] * (V[j] - V[i]));
}
coupling[i] = sum_coupling;
}
// printf("Done #1\n");
//Starting calculation using RK4
for (l = 0; l <= n_steps; l++)
{
//printf("%f\n",l*dt );
fprintf(fV_vs_t_id, "%f\t", l * dt);
fprintf(fmvalueId, "%f\n", l * dt);
fprintf(fhvalueId, "%f\n", l * dt);
fprintf(fnvalueId, "%f\n", l * dt);
fprintf(fm_noiseId, "%f\t", l * dt);
for (j = 0; j < N; j++)
{
alpha_m[j] = (0.1 * (25 - V[i])) / (exp((25 - V[i]) / 10) - 1);
beta_m[j] = 4 * exp(-V[i] / 18);
alpha_h[j] = 0.07 * exp(-V[i] / 20);
beta_h[j] = 1 / (exp((30 - V[i]) / 10) + 1);
alpha_n[j] = 0.01 * (10 - V[i]) / (exp((10 - V[i]) / 10) - 1);
beta_n[j] = 0.125 * exp(-V[i] / 80);
m_noise[j] = sqrt(((2 * alpha_m[j] * beta_m[j]) / (Nna * xna * (alpha_m[j] + beta_m[j])))) * gaussrandm();
fprintf(fm_noiseId, "%f\t", m_noise[j]);
n_noise[j] = sqrt(((2 * alpha_n[j] * beta_n[j]) / (Nk * xk * (alpha_n[j] + beta_n[j])))) * gaussrandn();
h_noise[j] = sqrt(((2 * alpha_h[j] * beta_h[j]) / (Nna * xna * (alpha_h[j] + beta_h[j])))) * gaussrandh();
k1[j] = dt * KV(coupling[j], V[j], m[j], h[j], n[j]);
m1[j] = dt * (Km(V[j], m[j]) + m_noise[j]);
h1[j] = dt * (Kh(V[j], h[j]) + h_noise[j]);
n1[j] = dt * (Kn(V[j], n[j]) + n_noise[j]);
coupling1[j] = dt * Kcoupling(V, edgematrix, nodes, k1, j);
}
fprintf(fm_noiseId, "\n");
for (j = 0; j < N; j++)
{
k2[j] = dt * KV(coupling[j] + (0.5 * coupling1[j]), V[j] + (0.5 * k1[j]), m[j] + (0.5 * m1[j]), h[j] + (0.5 * h1[j]),n[j] + (0.5 * n1[j]));
m2[j] = dt * (Km(V[j] + (0.5 * k1[j]), m[j] + (0.5 * m1[j])) + m_noise[j]);
h2[j] = dt * (Kh(V[j] + (0.5 * k1[j]), h[j] + (0.5 * h1[j])) + h_noise[j]);
n2[j] = dt * (Kn(V[j] + (0.5 * k1[j]), n[j] + (0.5 * n1[j])) + n_noise[j]);
coupling2[j] = dt * Kcoupling(V, edgematrix, nodes, k2, j);
}
for (j = 0; j < N; j++)
{
k3[j] = dt * KV(coupling[j] + (0.5 * coupling2[j]), V[j] + (0.5 * k2[j]), m[j] + (0.5 * m2[j]), h[j] + (0.5 * h2[j]),n[j] + (0.5 * n2[j]));
m3[j] = dt * (Km(V[j] + (0.5 * k2[j]), m[j] + (0.5 * m2[j])) + m_noise[j]);
h3[j] = dt * (Kh(V[j] + (0.5 * k2[j]), h[j] + (0.5 * h2[j])) + h_noise[j]);
n3[j] = dt * (Kn(V[j] + (0.5 * k2[j]), n[j] + (0.5 * n2[j])) + n_noise[j]);
coupling3[j] = dt * Kcoupling1(V, edgematrix, nodes, k3, j);
}
for (j = 0; j < N; j++)
{
k4[j] = dt * KV(coupling[j] + coupling3[j], V[j] + k3[j], m[j] + m3[j], h[j] + h3[j], n[j] + n3[j]);
m4[j] = dt * (Km(V[j] + k3[j], m[j] + m3[j]) + m_noise[j]);
h4[j] = dt * (Kh(V[j] + k3[j], h[j] + h3[j]) + h_noise[j]);
n4[j] = dt * (Kn(V[j] + k3[j], n[j] + n3[j]) + n_noise[j]);
}
for (j = 0; j < N; j++)
{
V[j] = V[j] + ((k1[j] + 2 * k2[j] + 2 * k3[j] + k4[j]) / 6);
m[j] = m[j] + ((m1[j] + 2 * m2[j] + 2 * m3[j] + m4[j]) / 6);
h[j] = h[j] + ((h1[j] + 2 * h2[j] + 2 * h3[j] + h4[j]) / 6);
n[j] = n[j] + ((n1[j] + 2 * n2[j] + 2 * n3[j] + n4[j]) / 6);
fprintf(fV_vs_t_id, "%f\t", V[j]);
fprintf(fVTid, "%f\t", l * dt);
fprintf(fVTid, "%f\n", V[j]);
fprintf(fmvalueId, "%f\t", m[j]);
fprintf(fhvalueId, "%f\t", h[j]);
fprintf(fnvalueId, "%f\t", n[j]);
}
fprintf(fV_vs_t_id, "\n");
fprintf(fmvalueId, "\n");
fprintf(fhvalueId, "\n");
fprintf(fnvalueId, "\n");
for (i = 0; i < N; i++)
{
sum_coupling = 0.0;
for (j = 0; j < N; j++)
{
sum_coupling = sum_coupling + (edgematrix[i][j] * (V[j] - V[i]));
}
coupling[i] = sum_coupling;
}
}
fclose(fAdjacencymatrixId);
fclose(fV_vs_t_id);
fclose(fVTid);
fclose(fNoConnectionsId);
fclose(frandomnumberId);
fclose(fmvalueId);
fclose(fnvalueId);
fclose(fhvalueId);
//fclose(fMeanShortestPathId);
//fclose(fClusteringCoeffId);
//________________________________________________________________________________________________________________________________________
// printf("Done #2\n");
//Calculation of ISI, spike times, firing correlation, average firing coherence etc.
double f_correlation[N][N];
float tmp0 = 0.0;
float tmp1 = 0.0;
int s = 0;
int a = 0;
int b = 0;
int c = 0;
double z = 0.0;
int smax = 0;
char ignore[1024];
double t1 = 0.0;
double t2 = timewell;
int no_cycles = (int)(time_max / timewell);
double sum_total = 0.0;
for (i = 0; i < N; i++)
{
//no_spikes[i] = 0;
for (j = 0; j < N; j++)
{
f_correlation[i][j] = 0.0;
}
}
strcpy(file_path, base_path);
strcat(file_path, "VT.txt");
fVTid = fopen(file_path, "r");
float voltagematrix[n_steps];
float timematrix[n_steps];
for (i = 0; i < n_steps; i++)
{
voltagematrix[i] = 0.0;
timematrix[i] = 0.0;
}
float tspike[N][n_steps / n_one_cycle];
for (i = 0; i < N; i++)
for (j = 0; j < (n_steps / n_one_cycle); j++)
tspike[i][j] = 0;
// printf("Done #3\n");
for (i = 0; i < N; i++)
{
//countnotimes = 0;
s = 0;
tmp0 = 0.0;
tmp1 = 0.0;
// printf("loop0\n");
for (j = 0; j < i; j++)
{
fgets(ignore, sizeof(ignore), fVTid);
// printf("loop1\n");
}
for (l = 0; l < n_steps; l++)
{
fscanf(fVTid, "%f %f", &timematrix[l], &voltagematrix[l]); // reading from file
// printf("loop2\n");
for (a = 0; a < N; a++)
{
fgets(ignore, sizeof(ignore), fVTid);
// printf("loop3\n");
}
}
//printf("%f\n",voltagematrix[1500]);
for (b = 1; b <= n_steps - 1; b++)
{
//printf("Here\n");
//countnotimes = countnotimes + 1;
tmp0 = voltagematrix[b] - voltagematrix[b + 1];
tmp1 = voltagematrix[b] - voltagematrix[b - 1];
// printf("loop4\n");
if (tmp0 > 0 && tmp1 > 0)
{
if (voltagematrix[b] > 70.0)
{
tspike[i][s] = timematrix[b];
if (floor(tspike[i][s]) == floor(tspike[i][s - 1]) || floor(tspike[i][s]) == ceil(tspike[i][s - 1]))
{
tspike[i][s] = 0.0;
continue;
}
fprintf(fspiketimeid, "%f\t", tspike[i][s]);
// printf("loop5\n");
s = s + 1;
no_spikes[i] = s;
if (s > smax)
{
smax = s;
}
}
}
}
//printf("%d\n",countnotimes);
fprintf(fspiketimeid, "\n");
// printf("loop6\n");
rewind(fVTid);
// printf("loop7\n");
// printf("No of spikes of neuron %d: %d\n",i+1,no_spikes[i]);
}
// printf("Done #4\n");
int flag = 0;
for (i = 0; i < N; i++)
{
if (no_spikes[i] == 0)
flag = 1;
}
// if (flag == 1)
// {
// trial = trial - 1;
// printf("Re-simulating, no spikes detected\n");
// continue;
// }
double AvgISI[N];
double ISI = 0.0;
int count_isi = 0;
for (i = 0; i < N; i++)
{
AvgISI[i] = 0.0;
}
for (i = 0; i < N; i++)
{
count_isi = 0;
for (j = 1; j < smax; j++)
{
if (tspike[i][j] == 0.0)
{
continue;
}
ISI = tspike[i][j] - tspike[i][j - 1];
AvgISI[i] = AvgISI[i] + ISI;
count_isi = count_isi + 1;
}
AvgISI[i] = AvgISI[i] / count_isi;
}
for (i = 0; i < N; i++)
{
FinalISI[i] = FinalISI[i] + AvgISI[i]; // ISI averaged over all neurons
}
fclose(fspiketimeid);
int Y[N][no_cycles];
/*int **Y;
* Y = (int **)malloc(N*sizeof(float));
* for(c = 0; c < N; c++)
* {
* Y[c] = (int *)malloc(no_cycles * sizeof(int));
* }
*/
for (i = 0; i < N; i++)
{
for (j = 0; j < no_cycles; j++)
{
Y[i][j] = 0;
}
}
for (i = 0; i < N; i++)
{
for (a = 0; a < (n_steps / n_one_cycle); a++) // n_steps/n_one_cycle is value of time bin
{
if (tspike[i][a] == 0)
continue;
int bin_number = (int)(floor(tspike[i][a]) / timewell); // timewell = n_steps/n_one_cycle
Y[i][bin_number] = 1;
}
}
for (i = 0; i < N; i++)
{
for (j = 0; j < no_cycles; j++)
{
fprintf(yid, "%d\t", Y[i][j]);
}
fprintf(yid, "\n");
}
int sum_spikes = 0;
for (i = 0; i < N - 1; i++)
{
for (j = i + 1; j < N; j++)
{
for (l = 0; l < no_cycles; l++)
{
if (Y[i][l] == 1 && Y[j][l] == 1)
{
sum_spikes = sum_spikes + 1;
}
}
f_correlation[i][j] = (double)sum_spikes / sqrt(no_spikes[i] * no_spikes[j]);
f_correlation[j][i] = (double)sum_spikes / sqrt(no_spikes[i] * no_spikes[j]);
sum_spikes = 0;
}
}
for (i = 0; i < N - 1; i++)
{
for (j = i + 1; j < N; j++)
{
sum_total = sum_total + f_correlation[i][j];
}
}
sum_total = 2.0 * sum_total / (N * (N - 1));
firing_coherence = firing_coherence + sum_total; // population coherence
fprintf(ftrial_output, "Firing Coherence: %f\n", sum_total);
fclose(yid);
int distance[N][N]; //Array containing shortest paths between all pairs of nodes // FLOYD WARSHALL Algorithm implementation
//int i,j,l;
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (edgematrix[i][j] == 0)
{
if (i == j)
{
distance[i][j] = 0;
distance[j][i] = 0;
}
else
{
distance[i][j] = 100; //100 is just a very large number. Symbolizes infinity.
distance[j][i] = 100;
}
}
else
{
distance[j][i] = 1;
distance[i][j] = 1;
}
}
}
//Calculating shortest paths
for (l = 0; l < N; l++)
{
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (distance[i][j] > (distance[i][l] + distance[l][j]))
{
distance[i][j] = distance[i][l] + distance[l][j];
}
else
continue;
}
}
}
int max_dist = 0;
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
// printf("%d\t",distance[i][j]);
if (distance[i][j] > max_dist)
max_dist = distance[i][j];
}
// printf("\n");
}
double fc_degree[max_dist]; // firing correlation by degree of separation.
for (i = 0; i < max_dist; i++)
fc_degree[i] = 0.0;
double sum_fc_degree = 0.0;
int count = 0;
for (i = 1; i <= max_dist; i++)
{
sum_fc_degree = 0.0;
count = 0;
for (j = 0; j < N - 1; j++)
{
for (l = i + 1; l < N; l++)
{
if (distance[j][l] == i)
{
sum_fc_degree = sum_fc_degree + f_correlation[j][l];
count = count + 1;
}
}
}
fc_degree[i - 1] = sum_fc_degree / count;
}
for (i = 0; i < max_dist; i++)
{
fprintf(ftrial_output, "%d: %f\n", i + 1, fc_degree[i]);
tot_degree[i] = tot_degree[i] + fc_degree[i];
count_degree[i] = count_degree[i] + 1;
}
fclose(ftrial_output);
MPI_Send(&(FinalISI[0]), 100, MPI_DOUBLE, rec_proc_rank, 0, MPI_COMM_WORLD);
MPI_Send(&(no_spikes[0]), 100, MPI_INT, rec_proc_rank, 1, MPI_COMM_WORLD);
MPI_Send(&(connections[0]), 100, MPI_DOUBLE, rec_proc_rank, 2, MPI_COMM_WORLD);
MPI_Send(&tot_degree[0], 12, MPI_DOUBLE, rec_proc_rank, 3, MPI_COMM_WORLD);
MPI_Send(&count_degree[0], 12, MPI_INT, rec_proc_rank, 4, MPI_COMM_WORLD);
MPI_Send(&firing_coherence, 1, MPI_DOUBLE, rec_proc_rank, 5, MPI_COMM_WORLD);
MPI_Send(&rec_proc_rank, 1, MPI_INT, rec_proc_rank, 6, MPI_COMM_WORLD);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
MPI_Finalize();
return 0;
}
static void *
apecs_pcib_cvt_dense(device_t dev, vm_offset_t addr)
{
addr &= 0xffffffffUL;
return (void *) KV(addr | APECS_PCI_DENSE);
}
static void *
lca_pcib_cvt_dense(device_t dev, vm_offset_t addr)
{
addr &= 0xffffffffUL;
return (void *) KV(addr | LCA_PCI_DENSE);
}
#include <alpha/tc/tc_conf.h>
#include <alpha/tc/tc_3000_500.h>
void tc_3000_500_intr_setup __P((void));
void tc_3000_500_intr_establish __P((struct device *, void *,
tc_intrlevel_t, int (*)(void *), void *));
void tc_3000_500_intr_disestablish __P((struct device *, void *));
void tc_3000_500_iointr __P((void *, unsigned long));
int tc_3000_500_intrnull __P((void *));
#define C(x) ((void *)(u_long)x)
#define KV(x) (ALPHA_PHYS_TO_K0SEG(x))
struct tc_slotdesc tc_3000_500_slots[] = {
{ KV(0x100000000), C(TC_3000_500_DEV_OPT0), }, /* 0 - opt slot 0 */
{ KV(0x120000000), C(TC_3000_500_DEV_OPT1), }, /* 1 - opt slot 1 */
{ KV(0x140000000), C(TC_3000_500_DEV_OPT2), }, /* 2 - opt slot 2 */
{ KV(0x160000000), C(TC_3000_500_DEV_OPT3), }, /* 3 - opt slot 3 */
{ KV(0x180000000), C(TC_3000_500_DEV_OPT4), }, /* 4 - opt slot 4 */
{ KV(0x1a0000000), C(TC_3000_500_DEV_OPT5), }, /* 5 - opt slot 5 */
{ KV(0x1c0000000), C(TC_3000_500_DEV_BOGUS), }, /* 6 - TCDS ASIC */
{ KV(0x1e0000000), C(TC_3000_500_DEV_BOGUS), }, /* 7 - IOCTL ASIC */
};
int tc_3000_500_nslots =
sizeof(tc_3000_500_slots) / sizeof(tc_3000_500_slots[0]);
struct tc_builtin tc_3000_500_graphics_builtins[] = {
{ "FLAMG-IO", 7, 0x00000000, C(TC_3000_500_DEV_IOASIC), },
{ "PMAGB-BA", 7, 0x02000000, C(TC_3000_500_DEV_CXTURBO), },
{ "PMAZ-DS ", 6, 0x00000000, C(TC_3000_500_DEV_TCDS), },
int main()
{
FILE *fV_vs_t_id;
clock_t start, end;
fV_vs_t_id = fopen("V_vs_t.txt", "w");
FILE *out1;
out1 = fopen("m.txt", "w");
FILE *out2;
out2 = fopen("h.txt", "w");
FILE *out3;
out3 = fopen("n.txt", "w");
FILE *fI_vs_t_id;
fI_vs_t_id = fopen("I_vs_t.txt", "w");
double runTime;
double dt,T,w,freq;
// double t_max;
// double freq_min, freq_max, dfreq ;
double time;
double GNa,GK,GL,VNa,VK,VL,c,R;
double alpham1,betam1,alphah1,betah1,alphan1,betan1 ;
double k11,m11,n11,h11,Iext11;
double k12,m12,n12,h12,Iext12;
double k13,m13,n13,h13,Iext13;
double k14,m14,n14,h14;
long i,j, jf, jI0;
long n_max;
//double Iext0_min, Iext0_max, dIext0;
double Iext0;
// long Num_I0, Num_freq;
char *forcing_param[30];
double *V1 ;
double *m1 ;
double *h1 ;
double *n1 ;
double *Iext;
start = clock();
// ************************ Fix neuron parameters*****************************************************
GNa=120 ;
GK = 36;
GL=0.3;
R = 30;
VNa = 115;
VK = -12;
VL=10.5995;
c = 1;
// *********************** Input parameter values (read from file below)*****************************************************
#include</home/himanshu/NeuronSimulations/OneFrequency/Code/WorkingDir/par_HH.h>
// *********************** Start the FREQUENCY loop **************************************************************
freq = freq_min;
for(jf = 0 ; jf < Num_freq ; jf++) {
//freq = freq + dfreq;
// ************************** Calculate T, dt, n_max and w (all of which depend on freq - loop is over frequency) *********
// Time period
T=(1/freq); // in seconds
printf("Time period (in seconds) = %3.10f \n \n",T);
// Time step
dt=(T/1000); // in seconds (time step is always chosen as (1/1000)th of the time period of ext current)
printf("Time step (in seconds) = %3.10f \n \n",dt);
// Number of time steps
n_max = t_max*freq*1000; // n_max = t_max / dt , where dt = T/1000 (1 time period divided into 1000 time intervals), and T = 1/freq
printf("Number of time steps = %d \n \n",n_max);
// Anglular frequency
w = freq*2*M_PI; // angular frequency (radians per second)
printf("Angular frequency (rad/second) = %3.10f \n \n",w);
// **************************** convert parameters to milliseconds (from seconds) *********************************
// Anglular frequency
w=(w/1000); // angular frequency (radians per millisecond)
printf("Angular frequency (rad/milli-second) = %3.10f \n \n",w);
// Time step
dt=dt*1000; // in milliseconds. Factor of 1000 converts dt to milliseconds.
printf("Time step (in milli-second) = %3.10f \n \n",dt);
V1 = (double *)malloc(n_max*sizeof(double));
m1 = (double *)malloc(n_max*sizeof(double));
h1 = (double *)malloc(n_max*sizeof(double));
n1 = (double *)malloc(n_max*sizeof(double));
Iext = (double *)malloc(n_max*sizeof(double));
// ***************************** Prepare simulation for a fresh value of forcing amplitude ***************************************
Iext0 = Iext0_min;
for(jI0 = 0 ; jI0 < Num_I0 ; jI0++) { // Loop over a range of current (external) amplitudes (Max number of current values = Num_I0)
printf("jI0= %f",jI0);
// Iext0 = Iext0 + dIext0; External current will be updated at the end of the loop
// ************* Initialize time, V[], m1, h1, n1 before starting RK4 *********************************
// Bring time back to zero
time=0;
// Bring back voltage and gate variables back to rest state
V1[0] = 0;
alpham1 = (0.1*(25-V1[0]))/(exp((25 - V1[0])/10) - 1);
betam1 = 4*exp(-V1[0]/18);
alphah1 = 0.07*exp(-V1[0]/20);
betah1 = 1/(exp((30-V1[0])/10) + 1);
alphan1 = 0.01*(10-V1[0])/(exp((10-V1[0])/10) - 1);
betan1 = 0.125*exp(-V1[0]/80);
m1[0] = (alpham1/(alpham1 + betam1));
h1[0] = (alphah1/(alphah1 + betah1));
n1[0] = (alphan1/(alphan1 + betan1));
fprintf(fV_vs_t_id,"\n");
fprintf(fV_vs_t_id,"\n");
fprintf(fV_vs_t_id,"%s %f \n","#Iext0=",Iext0);
fprintf(fV_vs_t_id,"%s %f \n","#Freq=",freq);
fprintf(fV_vs_t_id,"%d %f %f \n",0,time*0.00,V1[0]);
fprintf(fI_vs_t_id,"\n");
fprintf(fI_vs_t_id,"\n");
fprintf(fI_vs_t_id,"%s %f \n","#Iext0=",Iext0);
fprintf(fI_vs_t_id,"%s %f \n","#Freq=",freq);
// ***************************** START TIME STEPPING WITH RK4 ***************************************
for(i=0; i<n_max ; i++) // Loop over time for a chosen forcing parameter values
{
//printf("i= %d \n",i);
//time = time + dt;
time = (i+1)*dt;
//Time[i] = time ;
Iext[i]=Iext0*cos(w*time);
k11 = dt*KV(Iext[i],V1[i],m1[i],h1[i],n1[i],GNa,GK,GL,VNa,VK,VL,c);
m11 = dt*Km(V1[i],m1[i]);
h11 = dt*Kh(V1[i],h1[i]);
n11 = dt*Kn(V1[i],n1[i]);
Iext11=dt*KIext(time,w,Iext0);
k12 = dt*KV(Iext[i]+0.5*Iext11 ,V1[i]+(0.5*k11),m1[i]+(0.5*m11),h1[i]+(0.5*h11),n1[i]+(0.5*n11),GNa,GK,GL,VNa,VK,VL,c);
m12 = dt*Km(V1[i]+(0.5*k11),m1[i]+(0.5*m11));
h12 = dt*Kh(V1[i]+(0.5*k11),h1[i]+(0.5*h11));
n12 = dt*Kn(V1[i]+(0.5*k11),n1[i]+(0.5*n11));
Iext12=dt*KIext(time+0.5*dt,w,Iext0);
k13 = dt*KV(Iext[i]+0.5*Iext12 ,V1[i]+(0.5*k12),m1[i]+(0.5*m12),h1[i]+(0.5*h12),n1[i]+(0.5*n12),GNa,GK,GL,VNa,VK,VL,c);
m13 = dt*Km(V1[i]+(0.5*k12),m1[i]+(0.5*m12));
h13 = dt*Kh(V1[i]+(0.5*k12),h1[i]+(0.5*h12));
n13 = dt*Kn(V1[i]+(0.5*k12),n1[i]+(0.5*n12));
Iext13=dt*KIext(time+0.5*dt,w,Iext0);
k14 = dt*KV(Iext[i]+Iext13 ,V1[i]+k13,m1[i]+m13,h1[i]+h13,n1[i]+n13,GNa,GK,GL,VNa,VK,VL,c);
m14 = dt*Km(V1[i]+k13,m1[i]+m13);
h14 = dt*Kh(V1[i]+k13,h1[i]+h13);
n14 = dt*Kn(V1[i]+k13,n1[i]+n13);
V1[i+1] = V1[i] + ((k11 + 2*k12 + 2*k13 + k14)/6);
m1[i+1] = m1[i] + ((m11 + 2*m12 + 2*m13 + m14)/6);
h1[i+1] = h1[i] + ((h11 + 2*h12 + 2*h13 + h14)/6);
n1[i+1] = n1[i] + ((n11 + 2*n12 + 2*n13 +n14)/6);
fprintf(fV_vs_t_id,"%d %f %f \n",i+1,time*0.001,V1[i+1]);
//fprintf(out1," %f %f\n",m1[i+1],time);
//fprintf(out2," %f %f\n",h1[i+1],time);
//fprintf(out3," %f %f\n",n1[i+1],time);
fprintf(fI_vs_t_id," %d %f %f \n",i+1,time*0.001,Iext[i]);
} // end of RK4 loop
Iext0 = Iext0 + dIext0; // change the forcing amplitude value and simulate once again.
} // end of amplitude loop
freq = freq + dfreq; // change the forcing frequency value and simulate once again.
} // end of frequency loop
/* Plotter p = pl_alloc();
pl_add(p, n_max, Time, V1, "g*-");
pl_plot(p);
//}
//fclose(ofp);
end = clock();
runTime = (end - start) / (double) CLOCKS_PER_SEC ;
printf ("%f\n", runTime);
printf ("%d\n", Num_I0);
getchar(); */
fclose(fV_vs_t_id);
fclose(out1);
fclose(out2);
fclose(out3);
fclose(fI_vs_t_id);
return 0;
}
static void
apecs_swiz_outl(u_int32_t port, u_int32_t data)
{
SPARSE_WRITE_LONG(KV(APECS_PCI_SIO), port, data);
alpha_wmb();
}
static u_int32_t
apecs_swiz_inl(u_int32_t port)
{
alpha_mb();
return SPARSE_READ_LONG(KV(APECS_PCI_SIO), port);
}
static u_int16_t
apecs_swiz_inw(u_int32_t port)
{
alpha_mb();
return SPARSE_READ_WORD(KV(APECS_PCI_SIO), port);
}
static u_int8_t
apecs_swiz_inb(u_int32_t port)
{
alpha_mb();
return SPARSE_READ_BYTE(KV(APECS_PCI_SIO), port);
}
#include <sys/device.h>
#include <dev/tc/tcvar.h>
#include <pmax/pmax/maxine.h>
/*
* MAXINE has 4 TC option slot address space starting at 0x1000.0000.
* TC slot size is 64MB. Two option slots are available. Slot#2 is
* not available for option cards. IOASIC, which governs various
* baseboard devices like RTC, DMA assisted ASC SCSI, LANCE Ether,
* forms a system base. MAXINE IOASIC also controls ACCESS.bus
* keyboard/mouse, floppy disk and ISDN. IOASIC is designed as a TC
* device and sits in slot #3 space.
*/
static struct tc_slotdesc tc_xine_slots [4] = {
{ KV(XINE_PHYS_TC_0_START), C(SYS_DEV_OPT0), }, /* 0 - opt slot 0 */
{ KV(XINE_PHYS_TC_1_START), C(SYS_DEV_OPT1), }, /* 1 - opt slot 1 */
{ KV(XINE_PHYS_CFB_START), C(SYS_DEV_BOGUS), }, /* 2 - unused */
{ KV(XINE_PHYS_TC_3_START), C(SYS_DEV_BOGUS), }, /* 3 - IOASIC */
};
const struct tc_builtin tc_xine_builtins[] = {
{ "IOCTL ", 3, 0x0, C(3), },
{ "PMAG-DV ", 2, 0x0, C(SYS_DEV_OPT2), }, /* pretend as a TC device */
};
struct tcbus_attach_args xine_tc_desc = {
NULL, 0,
TC_SPEED_12_5_MHZ,
XINE_TC_NSLOTS, tc_xine_slots,
2, tc_xine_builtins,
IGL_INLINE void igl::copyleft::cgal::mesh_to_cgal_triangle_list(
const Eigen::PlainObjectBase<DerivedV> & V,
const Eigen::PlainObjectBase<DerivedF> & F,
std::vector<CGAL::Triangle_3<Kernel> > & T)
{
typedef CGAL::Point_3<Kernel> Point_3;
typedef CGAL::Triangle_3<Kernel> Triangle_3;
// Must be 3D
assert(V.cols() == 3);
// **Copy** to convert to output type (this is especially/only needed if the
// input type DerivedV::Scalar is CGAL::Epeck
Eigen::Matrix<
typename Kernel::FT,
DerivedV::RowsAtCompileTime,
DerivedV::ColsAtCompileTime>
KV(V.rows(),V.cols());
// Just use f'ing for loops. What if V and KV don't use same ordering?
for(int i = 0;i<V.rows();i++)
{
for(int j = 0;j<V.cols();j++)
{
assign_scalar(V(i,j),KV(i,j));
}
}
// Must be triangles
assert(F.cols() == 3);
T.reserve(F.rows());
// Loop over faces
for(int f = 0;f<(int)F.rows();f++)
{
T.push_back(
Triangle_3(
Point_3( KV(F(f,0),0), KV(F(f,0),1), KV(F(f,0),2)),
Point_3( KV(F(f,1),0), KV(F(f,1),1), KV(F(f,1),2)),
Point_3( KV(F(f,2),0), KV(F(f,2),1), KV(F(f,2),2))));
}
}
#include <pmax/pmax/kn01.h>
#include <pmax/pmax/kn230.h>
#include <pmax/pmax/pmaxtype.h>
static int ibus_pmax_match __P((struct device *, struct cfdata *, void *));
static void ibus_pmax_attach __P((struct device *, struct device *, void *));
CFATTACH_DECL(ibus_pmax, sizeof(struct ibus_softc),
ibus_pmax_match, ibus_pmax_attach, NULL, NULL);
#define KV(x) MIPS_PHYS_TO_KSEG1(x)
#ifdef DEC_3100
static struct ibus_attach_args ibus_pmax_devs[] = {
{ "pm", SYS_DEV_BOGUS, KV(KN01_PHYS_FBUF_START), 0 },
{ "dc", SYS_DEV_SCC0, KV(KN01_SYS_DZ), 0 },
{ "lance", SYS_DEV_LANCE, KV(KN01_SYS_LANCE), 0 },
{ "sii", SYS_DEV_SCSI, KV(KN01_SYS_SII), 0 },
{ "mc146818", SYS_DEV_BOGUS, KV(KN01_SYS_CLOCK), 0 },
};
static const int ibus_pmax_ndevs =
sizeof(ibus_pmax_devs)/sizeof(ibus_pmax_devs[0]);
#endif /* DEC_3100 */
#ifdef DEC_5100
static struct ibus_attach_args ibus_mipsmate_devs[] = {
{ "dc", SYS_DEV_SCC0, KV(KN230_SYS_DZ0), 0 },
{ "lance", SYS_DEV_LANCE, KV(KN230_SYS_LANCE), 0 },
{ "sii", SYS_DEV_SCSI, KV(KN230_SYS_SII), 0 },
{ "mc146818", SYS_DEV_BOGUS, KV(KN230_SYS_CLOCK), 0 },
int tc_3000_300_intrnull __P((void *));
#define C(x) ((void *)(u_long)x)
#define KV(x) (ALPHA_PHYS_TO_K0SEG(x))
/*
* We have to read and modify the IOASIC registers directly, because
* the TC option slot interrupt request and mask bits are stored there,
* and the ioasic code isn't initted when we need to frob some interrupt
* bits.
*/
#define DEC_3000_300_IOASIC_ADDR KV(0x1a0000000)
struct tc_slotdesc tc_3000_300_slots[] = {
{ KV(0x100000000), C(TC_3000_300_DEV_OPT0), }, /* 0 - opt slot 0 */
{ KV(0x120000000), C(TC_3000_300_DEV_OPT1), }, /* 1 - opt slot 1 */
{ KV(0x180000000), C(TC_3000_300_DEV_BOGUS), }, /* 2 - TCDS ASIC */
{ KV(0x1a0000000), C(TC_3000_300_DEV_BOGUS), }, /* 3 - IOCTL ASIC */
{ KV(0x1c0000000), C(TC_3000_300_DEV_CXTURBO), }, /* 4 - CXTurbo */
};
int tc_3000_300_nslots =
sizeof(tc_3000_300_slots) / sizeof(tc_3000_300_slots[0]);
struct tc_builtin tc_3000_300_builtins[] = {
{ "PMAGB-BA", 4, 0x02000000, C(TC_3000_300_DEV_CXTURBO), },
{ "FLAMG-IO", 3, 0x00000000, C(TC_3000_300_DEV_IOASIC), },
{ "PMAZ-DS ", 2, 0x00000000, C(TC_3000_300_DEV_TCDS), },
};
int tc_3000_300_nbuiltins =
sizeof(tc_3000_300_builtins) / sizeof(tc_3000_300_builtins[0]);
