int main(int argc, char* argv[])
{
terrama2::core::TerraMA2Init terramaRaii("example", 0);
{
QUrl uri;
uri.setScheme("postgis");
uri.setHost(QString::fromStdString(TERRAMA2_DATABASE_HOST));
uri.setPort(std::stoi(TERRAMA2_DATABASE_PORT));
uri.setUserName(QString::fromStdString(TERRAMA2_DATABASE_USERNAME));
uri.setPassword(QString::fromStdString(TERRAMA2_DATABASE_PASSWORD));
uri.setPath(QString::fromStdString("/"+TERRAMA2_DATABASE_DBNAME));
//DataProvider information
terrama2::core::DataProvider* dataProvider = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPtr(dataProvider);
dataProvider->uri = uri.url().toStdString();
dataProvider->intent = terrama2::core::DataProviderIntent::COLLECTOR_INTENT;
dataProvider->dataProviderType = "POSTGIS";
dataProvider->active = true;
auto& semanticsManager = terrama2::core::SemanticsManager::getInstance();
//DataSeries information
terrama2::core::DataSeries* dataSeries = new terrama2::core::DataSeries();
terrama2::core::DataSeriesPtr dataSeriesPtr(dataSeries);
dataSeries->semantics = semanticsManager.getSemantics("OCCURRENCE-postgis");
//DataSet information
terrama2::core::DataSetOccurrence* dataSet = new terrama2::core::DataSetOccurrence();
dataSet->active = true;
dataSet->format.emplace("table_name", "fires");
dataSet->format.emplace("timestamp_property", "data_pas");
dataSet->format.emplace("geometry_property", "geom");
dataSeries->datasetList.emplace_back(dataSet);
//accessing data
terrama2::core::DataAccessorOccurrencePostGIS accessor(dataProviderPtr, dataSeriesPtr);
//empty filter
terrama2::core::Filter filter;
boost::local_time::time_zone_ptr zone(new boost::local_time::posix_time_zone("+00"));
std::string dateTime = "2015-08-26 16:38:50";
boost::posix_time::ptime boostDate(boost::posix_time::time_from_string(dateTime));
boost::local_time::local_date_time date(boostDate.date(), boostDate.time_of_day(), zone, true);
filter.discardBefore = std::make_shared<te::dt::TimeInstantTZ>(date);
std::string dateTimeAfter = "2015-08-26 16:38:55";
boost::posix_time::ptime boostDateAfter(boost::posix_time::time_from_string(dateTimeAfter));
boost::local_time::local_date_time dateAfter(boostDateAfter.date(), boostDateAfter.time_of_day(), zone, true);
filter.discardAfter = std::make_shared<te::dt::TimeInstantTZ>(dateAfter);
std::string boundingBoxWkt = "POLYGON((-51.11 -17.74, -41.11 -17.74, -41.11 -20.83, -51.11 -20.83, -51.11 -17.74))";
te::gm::Geometry* geometry = te::gm::WKTReader::read(boundingBoxWkt.c_str());
geometry->setSRID(4326);
filter.region = std::shared_ptr<te::gm::Geometry>(geometry);
auto remover = std::make_shared<terrama2::core::FileRemover>();
terrama2::core::OccurrenceSeriesPtr occurrenceSeries = accessor.getOccurrenceSeries(filter, remover);
assert(occurrenceSeries->occurrencesMap().size() == 1);
auto teDataSet = (*occurrenceSeries->occurrencesMap().begin()).second.syncDataSet->dataset();
//Print column names and types (DateTime/Double)
int dateColumn = -1;
int geomColumn = -1;
std::string names, types;
for(int i = 0; i < teDataSet->getNumProperties(); ++i)
{
std::string name = teDataSet->getPropertyName(i);
names+= name + "\t";
if(name == "data_pas")
{
types+= "DataTime\t";
dateColumn = i;
}
else if(name == "geom")
{
types+= "Geometry\t";
geomColumn = i;
}
else
types+= "Int\t";
}
std::cout << names << std::endl;
std::cout << types << std::endl;
//Print values
teDataSet->moveBeforeFirst();
while(teDataSet->moveNext())
{
for(int i = 0; i < teDataSet->getNumProperties(); ++i)
{
if(teDataSet->isNull(i))
{
std::cout << "NULL";
continue;
}
if(i == dateColumn)
{
std::shared_ptr<te::dt::DateTime> dateTime = teDataSet->getDateTime(i);
std::cout << dateTime->toString();
}
else if(i == geomColumn)
{
std::cout << "<<Geometry>>";
}
else
{
std::cout << teDataSet->getInt32(i);
}
std::cout << "\t";
}
std::cout << std::endl;
}
std::cout << "\ndataset size: " << teDataSet->size() << std::endl;
}
return 0;
}
/** Parses .res4 file corresponding to dsname and returns a headerdef and
chunks suitable for sending off to FieldTrip. Also returns size of that
message payload in 'size'. Returns NULL on error.
Returned pointer needs to be disposed of using free() later.
*/
headerdef_t *handleRes4(const char *dsname, UINT32_T *size) {
headerdef_t *hdef;
char *res4name;
ft_chunk_t *chunk;
int i, len, pdot, pstart, rlen, offset, offsetNames, numFilters;
FILE *f;
union {
double d;
char b[8];
} fsamp;
/* printf("Picked up dataset name : %s\n", dsname); */
len = strlen(dsname);
pdot = len;
while (--pdot>0) {
if (dsname[pdot] == '.') break;
}
if (pdot == 0) {
fprintf(stderr, "No . found in dataset name - don't know where to pick up .res4 file\n");
return NULL;
}
pstart = pdot;
while (--pstart>0) {
if (dsname[pstart] == '/') {
/* slash at pstart -> increase because filename comes 1 character later */
pstart++;
break;
}
}
/* no slash found? then pstart = 0, which is fine - treat as relative path */
/* compose .res4 file name from dsname/dsname[pslash+1:pdot].res4 */
rlen = len + 1 + pdot - pstart + 5 + 1;
res4name = (char *) malloc(rlen);
if (res4name == NULL) {
fprintf(stderr, "Out of memory -- could not compose filename\n");
return NULL;
}
/* compose .res4 file name from dsname/dsname[pstart:pdot-1].res4 */
memcpy(res4name, dsname, len);
res4name[len] = '/';
memcpy(res4name + len + 1, dsname + pstart, pdot - pstart);
rlen = len + 1 + pdot - pstart;
res4name[rlen++] = '.';
res4name[rlen++] = 'r';
res4name[rlen++] = 'e';
res4name[rlen++] = 's';
res4name[rlen++] = '4';
res4name[rlen++] = 0;
/* printf("Trying to open %s\n", res4name); */
f = fopen(res4name, "rb");
if (f==NULL) {
fprintf(stderr, "File %s could not be opened\n", res4name);
free(res4name);
return NULL;
}
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, 0, SEEK_SET);
printf("\nCTF RES4 file %s contains %i bytes.\n", res4name, len);
free(res4name); /* not needed anymore */
/* get space for headerdef, 1x chunkdef, size of res4-file */
rlen = sizeof(headerdef_t) + sizeof(ft_chunkdef_t) + len;
hdef = (headerdef_t *) malloc(rlen);
if (hdef == NULL) {
fprintf(stderr, "Out of memory - can not allocate space for reading .res4 file\n");
fclose(f);
return NULL;
}
chunk = (ft_chunk_t *) (hdef+1); /* chunk starts directly after hdef */
if (fread(chunk->data, 1, len, f) != len) {
fprintf(stderr, "Could not read complete .res4 file\n");
fclose(f);
free(hdef);
return NULL;
}
fclose(f);
hdef->nsamples = 0;
hdef->nevents = 0;
/* .res4 file is big-endian, but we assume this machine to be little-endian */
hdef->nchans = getInt16(chunk->data + 1292);
printf("Number of channels: %i\n", hdef->nchans);
for (i=0;i<8;i++) {
fsamp.b[7-i] = chunk->data[1296+i];
}
hdef->fsample = (float) fsamp.d;
if (hdef->fsample < 1.0) {
printf("\nWARNING: suspicious sampling frequency (%f Hz) picked from .res4 -- setting to 1200 Hz\n\n", hdef->fsample);
hdef->fsample = 1200.0;
} else {
printf("Sampling frequency: %f Hz\n", hdef->fsample);
}
hdef->data_type = DATATYPE_INT32;
hdef->bufsize = sizeof(ft_chunkdef_t) + len;
chunk->def.type = FT_CHUNK_CTF_RES4;
chunk->def.size = len;
if (size != NULL) *size = rlen;
/* Ok, the header + chunk is ready, now parse some additional information
used internally
*/
/* set rlen to "run description length", see read_ctf_res4, line 92f */
rlen = getInt32(chunk->data + 1836);
/* offset points at first byte after run_desc */
offset = rlen + 1844;
/* "number of filters" */
numFilters = getInt16(chunk->data + offset);
offset += 2;
/* printf("numFilters = %i\n", numFilters); */
for (i=0;i<numFilters;i++) {
len = getInt16(chunk->data + offset+16);
offset += 18 + len;
/* printf("Filter %i: offset = %i, len = %i\n", i, offset, len); */
}
/* next we've got 32 bytes per channel (name) */
offsetNames = offset;
offset += 32 * hdef->nchans;
numTriggerChannels = 0;
for (i=0;i<hdef->nchans;i++) {
unsigned char ct = chunk->data[offset + 1 + 1328*i];
if (i<MAX_CHANNEL) {
sensType[i] = ct;
}
if (ct == CTF_TRIGGER_TYPE) {
if (numTriggerChannels < MAX_TRIGGER) {
int j;
char *tn = triggerChannelName[numTriggerChannels];
memcpy(tn, chunk->data + offsetNames + 32*i, 32);
for (j=0;j<32;j++) {
if (tn[j] <= 32 || tn[j] == '-') break;
}
triggerChannelNameLen[numTriggerChannels] = j;
triggerChannel[numTriggerChannels] = i;
printf("Trigger channel @ %i: %.*s\n", i, j, tn);
++numTriggerChannels;
}
}
}
for (i=0;i<numTriggerChannels;i++) {
lastValue[i] = 0;
}
return hdef;
}
int Hdf::compare(int32 v2) const {
int32 v1 = getInt32();
if (v1 == v2) return 0;
return v1 > v2 ? 1 : -1;
}
void LLVMColumnMapProjectionBuilder::build(ScanQuery* query) {
auto& srcRecord = mContext.record();
auto& destRecord = query->record();
// -> auto mainPage = reinterpret_cast<const ColumnMapMainPage*>(page);
auto mainPage = CreateBitCast(getParam(page), mMainPageStructTy->getPointerTo());
// -> auto count = static_cast<uint64_t>(mainPage->count);
auto count = CreateInBoundsGEP(mainPage, { getInt64(0), getInt32(0) });
count = CreateZExt(CreateAlignedLoad(count, 4u), getInt64Ty());
// -> auto index = static_cast<uint64_t>(idx);
auto index = CreateZExt(getParam(idx), getInt64Ty());
if (destRecord.headerSize() != 0u) {
// -> auto headerOffset = static_cast<uint64_t>(mainPage->headerOffset);
auto headerOffset = CreateInBoundsGEP(mainPage, { getInt64(0), getInt32(1) });
headerOffset = CreateZExt(CreateAlignedLoad(headerOffset, 4u), getInt64Ty());
// -> auto headerData = page + headerOffset + idx;
auto headerData = CreateAdd(headerOffset, index);
headerData = CreateInBoundsGEP(getParam(page), headerData);
auto i = query->projectionBegin();
for (decltype(destRecord.fieldCount()) destFieldIdx = 0u; destFieldIdx < destRecord.fieldCount();
++i, ++destFieldIdx) {
auto srcFieldIdx = *i;
auto& srcMeta = srcRecord.getFieldMeta(srcFieldIdx);
auto& destMeta = destRecord.getFieldMeta(destFieldIdx);
auto& field = destMeta.field;
if (field.isNotNull()) {
continue;
}
// -> auto srcData = headerData + page->count * srcNullIdx
auto srcData = headerData;
if (srcMeta.nullIdx != 0) {
srcData = CreateInBoundsGEP(headerData, createConstMul(count, srcMeta.nullIdx));
}
// -> auto nullValue = *srcData;
auto nullValue = CreateAlignedLoad(srcData, 1u);
// -> auto destData = dest + destNullIdx;
auto destData = getParam(dest);
if (destMeta.nullIdx != 0) {
destData = CreateInBoundsGEP(destData, getInt64(destMeta.nullIdx));
}
// -> *destData = srcValue;
CreateAlignedStore(nullValue, destData, 1u);
}
}
auto i = query->projectionBegin();
if (destRecord.fixedSizeFieldCount() != 0) {
// -> auto fixedOffset = static_cast<uint64_t>(mainPage->fixedOffset);
auto fixedOffset = CreateInBoundsGEP(mainPage, { getInt64(0), getInt32(2) });
fixedOffset = CreateZExt(CreateAlignedLoad(fixedOffset, 4u), getInt64Ty());
// -> auto fixedData = page + fixedOffset;
auto fixedData = CreateInBoundsGEP(getParam(page), fixedOffset);
for (decltype(destRecord.fixedSizeFieldCount()) destFieldIdx = 0u;
destFieldIdx < destRecord.fixedSizeFieldCount(); ++i, ++destFieldIdx) {
auto srcFieldIdx = *i;
auto& srcMeta = mContext.fixedMetaData()[srcFieldIdx];
auto& destMeta = destRecord.getFieldMeta(destFieldIdx);
auto& field = destMeta.field;
LOG_ASSERT(field.isFixedSized(), "Field must be fixed size");
auto fieldAlignment = field.alignOf();
auto fieldPtrType = getFieldPtrTy(field.type());
// -> auto srcData = reinterpret_cast<const T*>(fixedData + srcMeta.offset) + index;
auto srcData = fixedData;
if (srcMeta.offset != 0) {
srcData = CreateInBoundsGEP(srcData, createConstMul(count, srcMeta.offset));
}
srcData = CreateBitCast(srcData, fieldPtrType);
srcData = CreateInBoundsGEP(srcData, index);
// -> auto value = *srcData;
auto value = CreateAlignedLoad(srcData, fieldAlignment);
// -> auto destData = reinterpret_cast<const T*>(dest + destMeta.offset);
auto destData = getParam(dest);
if (destMeta.offset != 0) {
destData = CreateInBoundsGEP(destData, getInt64(destMeta.offset));
}
destData = CreateBitCast(destData, fieldPtrType);
// -> *destData = value;
CreateAlignedStore(value, destData, fieldAlignment);
}
}
// -> auto destHeapOffset = destRecord.staticSize();
llvm::Value* destHeapOffset = getInt32(destRecord.staticSize());
if (destRecord.varSizeFieldCount() != 0) {
auto srcFieldIdx = srcRecord.fixedSizeFieldCount();
decltype(destRecord.varSizeFieldCount()) destFieldIdx = 0;
// auto variableOffset = static_cast<uint64_t>(mainPage->variableOffset);
auto variableOffset = CreateInBoundsGEP(mainPage, { getInt64(0), getInt32(3) });
variableOffset = CreateZExt(CreateAlignedLoad(variableOffset, 4u), getInt64Ty());
// -> auto variableData = reinterpret_cast<const ColumnMapHeapEntry*>(page + variableOffset) + idx;
auto variableData = CreateInBoundsGEP(getParam(page), variableOffset);
variableData = CreateBitCast(variableData, mHeapEntryStructTy->getPointerTo());
variableData = CreateInBoundsGEP(variableData, index);
// -> auto srcData = variableData;
auto srcData = variableData;
// -> auto destData = reinterpret_cast<uint32_t*>(dest + destRecord.variableOffset());
auto destData = getParam(dest);
if (destRecord.variableOffset() != 0) {
destData = CreateInBoundsGEP(destData, getInt64(destRecord.variableOffset()));
}
destData = CreateBitCast(destData, getInt32PtrTy());
// -> *destData = destHeapOffset;
CreateAlignedStore(destHeapOffset, destData, 4u);
do {
if (*i != srcFieldIdx) {
auto step = *i - srcFieldIdx;
// -> srcData += count * (*i - srcFieldIdx);
srcData = CreateInBoundsGEP(srcData, createConstMul(count, step));
srcFieldIdx = *i;
}
// -> auto srcHeapOffset = srcData->offset;
auto srcHeapOffset = CreateInBoundsGEP(srcData, { getInt64(0), getInt32(0) });
srcHeapOffset = CreateAlignedLoad(srcHeapOffset, 8u);
// -> auto offsetCorrection = srcHeapOffset - destHeapOffset;
auto offsetCorrection = CreateSub(srcHeapOffset, destHeapOffset);
llvm::Value* offset;
do {
++i;
// Step to offset of the following field (or to the last field of the previous element) to get the end
// offset
++srcFieldIdx;
if (srcFieldIdx == srcRecord.fieldCount()) {
// -> srcData = variableData - 1;
srcData = CreateGEP(variableData, getInt64(-1));
} else {
// -> srcData += count;
srcData = CreateInBoundsGEP(srcData, count);
}
// -> auto offset = srcData->offset - offsetCorrection;
offset = CreateInBoundsGEP(srcData, { getInt64(0), getInt32(0) });
offset = CreateAlignedLoad(offset, 8u);
offset = CreateSub(offset, offsetCorrection);
// -> ++destData;
++destFieldIdx;
destData = CreateInBoundsGEP(destData, getInt64(1));
// -> *destData = offset;
CreateAlignedStore(offset, destData, 4u);
} while (destFieldIdx < destRecord.varSizeFieldCount() && *i == srcFieldIdx);
// -> auto srcHeap = page + static_cast<uint64_t>(srcHeapOffset);
auto srcHeap = CreateInBoundsGEP(getParam(page), CreateZExt(srcHeapOffset, getInt64Ty()));
// -> auto destHeap = dest + static_cast<uint64_t>(destHeapOffset);
auto destHeap = CreateInBoundsGEP(getParam(dest), CreateZExt(destHeapOffset, getInt64Ty()));
// -> auto length = offset - destHeapOffset
auto length = CreateSub(offset, destHeapOffset);
// -> memcpy(destHeap, srcHeap, length);
CreateMemCpy(destHeap, srcHeap, length, 1u);
// -> destHeapOffset = offset;
destHeapOffset = offset;
} while (destFieldIdx < destRecord.varSizeFieldCount());
}
// -> return destHeapOffset;
CreateRet(destHeapOffset);
}
static int decodeOperands(EjsMod *mp, EjsOptable *opt, char *argbuf, int argbufLen, int address, int *stackEffect)
{
EjsString *sval;
int *argp;
char *bufp;
uchar *start;
double dval;
int i, argc, ival, len, buflen, j, numEntries;
*stackEffect = opt->stackEffect;
/*
Keep a local progressive pointer into the argbuf and a length of the remaining room in the buffer.
*/
*argbuf = '\0';
bufp = argbuf;
buflen = argbufLen;
for (argc = 0, argp = opt->args; *argp; argc++, argp++) ;
start = mp->pc;
ival = 0;
for (i = 0, argp = opt->args; i < argc; i++) {
switch (opt->args[i]) {
case EBC_NONE:
break;
case EBC_BYTE:
ival = getByte(mp);
mprSprintf(bufp, buflen, "<%d> ", ival);
break;
case EBC_DOUBLE:
dval = getDouble(mp);
mprSprintf(bufp, buflen, "<%f> ", dval);
break;
case EBC_ARGC:
case EBC_ARGC2:
ival = (int) getNum(mp);
mprSprintf(bufp, buflen, "<argc: %d> ", ival);
break;
case EBC_ARGC3:
ival = (int) getNum(mp);
mprSprintf(bufp, buflen, "<argc: %d> ", ival);
break;
case EBC_NEW_ARRAY:
ival = (int) getNum(mp); /* argc */
mprSprintf(bufp, buflen, "<argc: %d>", ival);
bufp += strlen(bufp);
*stackEffect -= (ival * 2);
break;
case EBC_NEW_OBJECT:
ival = (int) getNum(mp); /* argc */
mprSprintf(bufp, buflen, "<argc: %d> <att: ", ival);
bufp += strlen(bufp);
for (j = 0; j < ival; j++) {
/* Discard attributes */ getNum(mp);
mprSprintf(bufp, buflen, "%d ", ival);
len = (int) strlen(bufp);
bufp += len;
buflen -= len;
}
mprSprintf(bufp, buflen, ">", ival);
*stackEffect -= (ival * 3);
break;
case EBC_SLOT:
ival = (int) getNum(mp);
mprSprintf(bufp, buflen, "<slot: %d> ", ival);
break;
case EBC_NUM:
ival = (int) getNum(mp);
mprSprintf(bufp, buflen, "<%d> ", ival);
break;
case EBC_JMP8:
ival = getByte(mp);
mprSprintf(bufp, buflen, "<addr: %d> ", ((char) ival) + address + 1);
break;
case EBC_JMP:
ival = getInt32(mp);
mprSprintf(bufp, buflen, "<addr: %d> ", ival + address + 4);
break;
case EBC_INIT_DEFAULT8:
numEntries = getByte(mp);
mprSprintf(bufp, buflen, "<%d> ", numEntries);
len = (int) strlen(bufp);
bufp += len;
buflen -= len;
for (j = 0; j < numEntries; j++) {
ival = getByte(mp);
mprSprintf(bufp, buflen, "<%d> ", ival + 2);
len = (int) strlen(bufp);
bufp += len;
buflen -= len;
}
break;
case EBC_INIT_DEFAULT:
numEntries = getByte(mp);
mprSprintf(bufp, buflen, "<%d> ", numEntries);
len = (int) strlen(bufp);
bufp += len;
buflen -= len;
for (j = 0; j < numEntries; j++) {
ival = getInt32(mp);
mprSprintf(bufp, buflen, "<%d> ", ival + 2);
len = (int) strlen(bufp);
bufp += len;
buflen -= len;
}
break;
case EBC_STRING:
sval = getString(mp->ejs, mp);
mprAssert(sval);
mprSprintf(bufp, buflen, "<%@> ", sval);
break;
case EBC_GLOBAL:
getGlobal(mp, bufp, buflen);
break;
default:
mprError("Bad arg type in opcode table");
break;
}
len = (int) strlen(bufp);
bufp += len;
buflen -= len;
if (opt->args[i] == EBC_ARGC) {
*stackEffect -= ival;
} else if (opt->args[i] == EBC_ARGC2) {
*stackEffect -= (ival * 2);
} else if (opt->args[i] == EBC_ARGC3) {
*stackEffect -= (ival * 3);
}
if (i == 0 && opt->stackEffect == EBC_POPN) {
*stackEffect = -ival;
}
}
return (int) (mp->pc - start);
}
bool compile(const nstr& name,
NNet& network,
size_t threads){
RunNetwork* runNetwork = new RunNetwork;
NNet::Layer* inputLayer = network.layer(0);
size_t numLayers = network.numLayers();
RunLayer* lastRunLayer = 0;
for(size_t l = 1; l < numLayers; ++l){
RunLayer* runLayer = new RunLayer;
runLayer->queue = new Queue(threads);
size_t inputLayerSize = inputLayer->size();
NNet::Layer* layer = network.layer(l);
size_t layerSize = layer->size();
if(l > 1){
runLayer->inputVecStart = lastRunLayer->outputVecStart;
runLayer->inputVec = lastRunLayer->outputVec;
}
if(l < numLayers - 1){
double* outputVecPtrStart;
double* outputVecPtr;
allocVector(layerSize, &outputVecPtrStart, &outputVecPtr);
runLayer->outputVecStart = outputVecPtrStart;
runLayer->outputVec = outputVecPtr;
}
TypeVec args;
args.push_back(getPointer(doubleVecType(inputLayerSize)));
args.push_back(getPointer(doubleVecType(inputLayerSize)));
args.push_back(getPointer(doubleType()));
args.push_back(int32Type());
FunctionType* ft = FunctionType::get(voidType(), args, false);
Function* f =
Function::Create(ft, Function::ExternalLinkage,
name.c_str(), &module_);
BasicBlock* entry = BasicBlock::Create(context_, "entry", f);
builder_.SetInsertPoint(entry);
auto aitr = f->arg_begin();
Value* inputVecPtr = aitr;
inputVecPtr->setName("input_vec_ptr");
++aitr;
Value* weightVecPtr = aitr;
weightVecPtr->setName("weight_vec_ptr");
++aitr;
Value* outputVecPtr = aitr;
outputVecPtr->setName("output_vec_ptr");
++aitr;
Value* outputIndex = aitr;
outputIndex->setName("output_index");
Value* inputVec =
builder_.CreateLoad(inputVecPtr, "input_vec");
Value* weightVec =
builder_.CreateLoad(weightVecPtr, "weight_vec");
Value* mulVec =
builder_.CreateFMul(inputVec, weightVec, "mul_vec");
Value* sumActivation =
builder_.CreateExtractElement(mulVec, getInt32(0), "sum_elem");
for(size_t i = 1; i < inputLayerSize; ++i){
Value* elem =
builder_.CreateExtractElement(mulVec, getInt32(i), "sum_elem");
sumActivation =
builder_.CreateFAdd(sumActivation, elem, "sum_activation");
}
Value* output =
getActivationOutput(layer->neuron(0), sumActivation);
Value* outputElement =
builder_.CreateGEP(outputVecPtr, outputIndex, "out_elem");
builder_.CreateStore(output, outputElement);
builder_.CreateRetVoid();
runLayer->f = f;
runLayer->fp = (void (*)(void*, void*, void*, int))
engine_->getPointerToFunction(f);
for(size_t j = 0; j < layerSize; ++j){
NNet::Neuron* nj = layer->neuron(j);
RunNeuron* runNeuron = new RunNeuron;
runNeuron->layer = runLayer;
runNeuron->outputIndex = j;
double* weightVecPtrStart;
double* weightVecPtr;
allocVector(inputLayerSize, &weightVecPtrStart, &weightVecPtr);
runNeuron->weightVecStart = weightVecPtrStart;
runNeuron->weightVec = weightVecPtr;
for(size_t i = 0; i < inputLayerSize; ++i){
NNet::Neuron* ni = inputLayer->neuron(i);
weightVecPtr[i] = nj->weight(ni);
}
runLayer->queue->add(runNeuron);
}
runNetwork->layerVec.push_back(runLayer);
inputLayer = layer;
lastRunLayer = runLayer;
}
networkMap_.insert(make_pair(name, runNetwork));
return true;
}
