neuron_monitor_core.cpp

Go to the documentation of this file.

/* * Copyright (c) 2016 Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* 3. The names of its contributors may not be used to endorse or promote
*    products derived from this software without specific prior written
*    permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* *********************************************************************************************** *
* CARLsim
* created by: (MDR) Micah Richert, (JN) Jayram M. Nageswaran
* maintained by:
* (MA) Mike Avery <averym@uci.edu>
* (MB) Michael Beyeler <mbeyeler@uci.edu>,
* (KDC) Kristofor Carlson <kdcarlso@uci.edu>
* (TSC) Ting-Shuo Chou <tingshuc@uci.edu>
* (HK) Hirak J Kashyap <kashyaph@uci.edu>
*
* CARLsim v1.0: JM, MDR
* CARLsim v2.0/v2.1/v2.2: JM, MDR, MA, MB, KDC
* CARLsim3: MB, KDC, TSC
* CARLsim4: TSC, HK
* CARLsim5: HK, JX, KC
* CARLsim6: LN, JX, KC, KW
*
* CARLsim available from http://socsci.uci.edu/~jkrichma/CARLsim/
* Ver 05/24/2017
*/

#include <neuron_monitor_core.h>

#include <snn.h>                // CARLsim private implementation
#include <snn_definitions.h>    // KERNEL_ERROR, KERNEL_INFO, ...

#include <algorithm>            // std::sort

NeuronMonitorCore::NeuronMonitorCore(SNN* snn, int monitorId, int grpId) {
    snn_ = snn;
    grpId_= grpId;
    monitorId_ = monitorId;
    nNeurons_ = -1;
    neuronFileId_ = NULL;
    recordSet_ = false;
    neuronMonLastUpdated_ = 0;

    persistentData_ = false;
    userHasBeenWarned_ = false;
    needToWriteFileHeader_ = true;
    neuronFileSignature_ = 206661979;
    neuronFileVersion_ = 0.1f;

    // defer all unsafe operations to init function
    init();
}

void NeuronMonitorCore::init() {
    nNeurons_ = std::min(MAX_NEURON_MON_GRP_SZIE, snn_->getGroupNumNeurons(grpId_));    
    assert(nNeurons_>0);

    // so the first dimension is neuron ID
    vectorV_.resize(nNeurons_+1);  // reserve the record last for mean
    vectorU_.resize(nNeurons_+1);
    vectorI_.resize(nNeurons_+1);

    clear();

    // use KERNEL_{ERROR|WARNING|etc} typesetting (const FILE*)
    fpInf_ = snn_->getLogFpInf();
    fpErr_ = snn_->getLogFpErr();
    fpDeb_ = snn_->getLogFpDeb();
    fpLog_ = snn_->getLogFpLog();
}

NeuronMonitorCore::~NeuronMonitorCore() {
    if (neuronFileId_!=NULL) {
        fclose(neuronFileId_);
        neuronFileId_ = NULL;
    }
}

void NeuronMonitorCore::clear() {
    assert(!isRecording());
    recordSet_ = false;
    userHasBeenWarned_ = false;
    startTime_ = -1;
    startTimeLast_ = -1;
    stopTime_ = -1;
    accumTime_ = 0;
    totalTime_ = -1;

    for (int i=0; i<=nNeurons_; i++){  // including mean
        vectorV_[i].clear();
        vectorU_[i].clear();
        vectorI_[i].clear();
    }
}

void NeuronMonitorCore::pushNeuronState(int neurId, float V, float U, float I) {
    assert(isRecording());

    if (neurId >= MAX_NEURON_MON_GRP_SZIE)
        return; // ignore values as the are empty anyway (see buffer transfer)

    vectorV_[neurId].push_back(V);
    vectorU_[neurId].push_back(U);
    vectorI_[neurId].push_back(I);

    // update mean 
    const int n = vectorV_[neurId].size();
    if (vectorV_[nNeurons_].size() < n) {
        // set first element
        vectorV_[nNeurons_].push_back(V / nNeurons_);
        vectorU_[nNeurons_].push_back(U / nNeurons_);
        vectorI_[nNeurons_].push_back(I / nNeurons_);
    }
    else {
        // mean record was appended by other neuron
        vectorV_[nNeurons_][n-1] += V / nNeurons_;
        vectorU_[nNeurons_][n-1] += U / nNeurons_;
        vectorI_[nNeurons_][n-1] += I / nNeurons_;
    }
}

void NeuronMonitorCore::startRecording() {
    assert(!isRecording());

    if (!persistentData_) {
        // if persistent mode is off (default behavior), automatically call clear() here
        clear();
    }

    // call updateNeuronMonitor to make sure neuron state file and neuron state vector are up-to-date
    // Caution: must be called before recordSet_ is set to true!
    snn_->updateNeuronMonitor(grpId_);

    recordSet_ = true;
    long int currentTime = snn_->getSimTimeSec()*1000+snn_->getSimTimeMs();

    if (persistentData_) {
        // persistent mode on: accumulate all times
        // change start time only if this is the first time running it
        startTime_ = (startTime_<0) ? currentTime : startTime_;
        startTimeLast_ = currentTime;
        accumTime_ = (totalTime_>0) ? totalTime_ : 0;
    }
    else {
        // persistent mode off: we only care about the last probe
        startTime_ = currentTime;
        startTimeLast_ = currentTime;
        accumTime_ = 0;
    }
}

void NeuronMonitorCore::stopRecording() {
    assert(isRecording());
    assert(startTime_>-1 && startTimeLast_>-1 && accumTime_>-1);

    // call updateNeuronMonitor to make sure neuron state file and neuron state vector are up-to-date
    // Caution: must be called before recordSet_ is set to false!
    snn_->updateNeuronMonitor(grpId_);

    recordSet_ = false;
    userHasBeenWarned_ = false;
    stopTime_ = snn_->getSimTimeSec()*1000+snn_->getSimTimeMs();

    // total time is the amount of time of the last probe plus all accumulated time from previous probes
    totalTime_ = stopTime_-startTimeLast_ + accumTime_;
    assert(totalTime_>=0);
}

// returns the total accumulated time.
long int NeuronMonitorCore::getAccumTime(){
    return accumTime_;
}

void NeuronMonitorCore::setNeuronFileId(FILE* neuronFileId) {
    assert(!isRecording());

    // close previous file pointer if exists
    if (neuronFileId_!=NULL) {
        fclose(neuronFileId_);
        neuronFileId_ = NULL;
    }

    // set it to new file id
    neuronFileId_=neuronFileId;

    if (neuronFileId_==NULL)
        needToWriteFileHeader_ = false;
    else {
        // file pointer has changed, so we need to write header (again)
        needToWriteFileHeader_ = true;
        writeNeuronFileHeader();
    }
}

// write the header section of the neuron state file
void NeuronMonitorCore::writeNeuronFileHeader() {
    if (!needToWriteFileHeader_)
        return;

    // write file signature
    if (!fwrite(&neuronFileSignature_,sizeof(int),1,neuronFileId_))
        KERNEL_ERROR("NeuronMonitorCore: writeNeuronFileHeader has fwrite error");

    // write version number
    if (!fwrite(&neuronFileVersion_,sizeof(float),1,neuronFileId_))
        KERNEL_ERROR("NeuronMonitorCore: writeNeuronFileHeader has fwrite error");

    // write grid dimensions
    Grid3D grid = snn_->getGroupGrid3D(grpId_);
    int tmpInt = grid.numX;
    if (!fwrite(&tmpInt,sizeof(int),1,neuronFileId_))
        KERNEL_ERROR("NeuronMonitorCore: writeNeuronFileHeader has fwrite error");

    tmpInt = grid.numY;
    if (!fwrite(&tmpInt,sizeof(int),1,neuronFileId_))
        KERNEL_ERROR("NeuronMonitorCore: writeNeuronFileHeader has fwrite error");

    tmpInt = grid.numZ;
    if (!fwrite(&tmpInt,sizeof(int),1,neuronFileId_))
        KERNEL_ERROR("NeuronMonitorCore: writeNeuronFileHeader has fwrite error");

    // write MAX_NEURON_MON_GRP_SZIE
    int max_neuron_mon_group_size = MAX_NEURON_MON_GRP_SZIE;
    if (!fwrite(&max_neuron_mon_group_size,sizeof(int),1,neuronFileId_))
        KERNEL_ERROR("NeuronMonitorCore: writeNeuronFileHeader has fwrite error");

    needToWriteFileHeader_ = false;
}

long int NeuronMonitorCore::getBufferSize(){
    long int bufferSize=0; // in bytes
    for(int i=0; i<vectorV_.size();i++){
        bufferSize+=vectorV_[i].size()*sizeof(int);
    }
    return 3 * bufferSize;
}

// check if the state vector is getting large. If it is, return true once until
// stopRecording is called.
bool NeuronMonitorCore::isBufferBig(){
    if(userHasBeenWarned_)
        return false;
    else {
        //check if buffer is too big
        if(this->getBufferSize()>MAX_NEURON_MON_BUFFER_SIZE){
            userHasBeenWarned_=true;
            return true;
        }
        else {
            return false;
        }
    }
}

std::vector<std::vector<float> > NeuronMonitorCore::getVectorV(){
    assert(!isRecording());
    return vectorV_;
}

std::vector<std::vector<float> > NeuronMonitorCore::getVectorU(){
    assert(!isRecording());
    return vectorU_;
}

std::vector<std::vector<float> > NeuronMonitorCore::getVectorI(){
    assert(!isRecording());
    return vectorI_;
}

void NeuronMonitorCore::print(bool meanOnly) {
    assert(!isRecording());

    // how many spike times to display per row
    int dispVoltsPerRow = 7;

    // spike times only available in AER mode
    KERNEL_INFO("| Neur ID | volt");
    KERNEL_INFO("|- - - - -|- - - - - - - - - - - - - - - - - - - - - -- - - - - - - - - - - - -")

    for (int i=meanOnly?nNeurons_:0; i<=nNeurons_; i++) {  // with mean 
        char buffer[100];
        if (i < nNeurons_) {
#if defined(WIN32) || defined(WIN64)
            _snprintf(buffer, 100, "| %7d | ", i);
#else
            snprintf(buffer, 100, "| %7d | ", i);
#endif
        }
        else {
#if defined(WIN32) || defined(WIN64)
            _snprintf(buffer, 100, "| %7s | ", "mean");
#else
            snprintf(buffer, 100, "| %7s | ", "mean");
#endif
        }
        int nV = vectorV_[i].size();
        for (int j=0; j<nV; j++) {
            char volts[10];
#if defined(WIN32) || defined(WIN64)
            _snprintf(volts, 10, "%4.4f ", vectorV_[i][j]);
#else
            snprintf(volts, 10, "%4.4f ", vectorV_[i][j]);
#endif
            strcat(buffer, volts);
            if (j%dispVoltsPerRow == dispVoltsPerRow-1 && j<nV-1) {
                KERNEL_INFO("%s",buffer);
                strcpy(buffer,"|         |");
            }
        }
        KERNEL_INFO("%s",buffer);
    }

}