@Override protected void chunkInit(){ final int n_coef = _beta.length; sumWeightedCatX = MemoryManager.malloc8d(n_coef - (_dinfo._nums - _n_offsets)); sumWeightedNumX = MemoryManager.malloc8d(_dinfo._nums); sizeRiskSet = MemoryManager.malloc8d(_n_time); sizeCensored = MemoryManager.malloc8d(_n_time); sizeEvents = MemoryManager.malloc8d(_n_time); countEvents = MemoryManager.malloc8(_n_time); sumRiskEvents = MemoryManager.malloc8d(_n_time); sumLogRiskEvents = MemoryManager.malloc8d(_n_time); rcumsumRisk = MemoryManager.malloc8d(_n_time); sumXEvents = malloc2DArray(_n_time, n_coef); sumXRiskEvents = malloc2DArray(_n_time, n_coef); rcumsumXRisk = malloc2DArray(_n_time, n_coef); sumXXRiskEvents = malloc3DArray(_n_time, n_coef, n_coef); rcumsumXXRisk = malloc3DArray(_n_time, n_coef, n_coef); }
public AppendableVec( Key key, long [] espc, int chunkOff) { super(key, (long[])null); _espc = espc; _chunkTypes = MemoryManager.malloc1(espc.length); _chunkOff = chunkOff; }
protected void cancel_sparse(){ if(_sparseLen != _len){ if(_ds == null){ int [] xs = MemoryManager.malloc4(_len); long [] ls = MemoryManager.malloc8(_len); for(int i = 0; i < _sparseLen; ++i){ xs[_id[i]] = _xs[i]; ls[_id[i]] = _ls[i]; } _xs = xs; _ls = ls; } else { double [] ds = MemoryManager.malloc8d(_len); for(int i = 0; i < _sparseLen; ++i) ds[_id[i]] = _ds[i]; _ds = ds; } _sparseLen = _len; } _id = null; } // Study this NewVector and determine an appropriate compression scheme.
public Row(boolean sparse, int nNums, int nBins, int nresponses, int i, long start) { binIds = MemoryManager.malloc4(nBins); numVals = MemoryManager.malloc8d(nNums); response = MemoryManager.malloc8d(nresponses); if(sparse) numIds = MemoryManager.malloc4(nNums); this.nNums = sparse?0:nNums; cid = i; rid = start + i; }
public double [] gradient(){ double [] res = MemoryManager.malloc8d(_gradient.length*_gradient[0].length); int P = _gradient.length; for(int k = 0; k < _gradient[0].length; ++k) for(int i = 0; i < _gradient.length; ++i) res[k*P + i] = _gradient[i][k]; return res; } }
@Override public void map(Chunk [] chunks){ _res = new GLMValidation(null,_model.glm,_model.rank(_lambda)); final int nrows = chunks[0]._len; double [] row = MemoryManager.malloc8d(_model._names.length); float [] preds = MemoryManager.malloc4f(_model.glm.family == Family.binomial?3:1); OUTER: for(int i = 0; i < nrows; ++i){ if(chunks[chunks.length-1].isNA0(i))continue; for(int j = 0; j < chunks.length-1; ++j){ if(chunks[j].isNA0(i))continue OUTER; row[j] = chunks[j].at0(i); } _model.score0(row, preds); double response = chunks[chunks.length-1].at0(i); _res.add(response, _model.glm.family == Family.binomial?preds[2]:preds[0]); } } @Override public void reduce(GLMValidationTask gval){_res.add(gval._res);}
@Override void init0() { _sums = MemoryManager.malloc8(_nbin); }
int[] sortedMap = MemoryManager.arrayCopyOf(map, map.length); Arrays.sort(sortedMap); for (int i = 1; i < sortedMap.length; ++i) for (int i = 0; i < names.length; ++i) m.put(names[i], i); int[] newMap = MemoryManager.malloc4(dom.length); for (int i = 0; i < map.length; ++i) { if (_removedCols.contains(dom[map[i]])) { error("beta_constraints", "Unknown column name '" + s + "'"); if ((v = beta_constraints.vec("beta_start")) != null) { _betaStart = MemoryManager.malloc8d(_dinfo.fullN() + (_dinfo._intercept ? 1 : 0)); for (int i = 0; i < (int) v.length(); ++i) if (map[i] != -1) _betaGiven = MemoryManager.malloc8d(_dinfo.fullN() + (_dinfo._intercept ? 1 : 0)); for (int i = 0; i < (int) v.length(); ++i) if (map[i] != -1) _betaUB = MemoryManager.malloc8d(_dinfo.fullN() + (_dinfo._intercept ? 1 : 0)); Arrays.fill(_betaUB, Double.POSITIVE_INFINITY); for (int i = 0; i < (int) v.length(); ++i) _betaLB = MemoryManager.malloc8d(_dinfo.fullN() + (_dinfo._intercept ? 1 : 0)); Arrays.fill(_betaLB, Double.NEGATIVE_INFINITY); for (int i = 0; i < (int) v.length(); ++i) _rho = MemoryManager.malloc8d(_dinfo.fullN() + (_dinfo._intercept ? 1 : 0));
public Row(boolean sparse, double[] numVals, int[] binIds, double[] response, int i, long start) { int nNums = numVals == null ? 0:numVals.length; this.numVals = numVals; if(sparse) numIds = MemoryManager.malloc4(nNums); this.nNums = sparse ? 0:nNums; this.nBins = binIds == null ? 0:binIds.length; this.binIds = binIds; this.response = response; cid = i; rid = start + i; }
treeprops._leftChildren = MemoryManager.malloc4(sharedTreeSubgraph.nodesArray.size()); treeprops._rightChildren = MemoryManager.malloc4(sharedTreeSubgraph.nodesArray.size()); treeprops._descriptions = new String[sharedTreeSubgraph.nodesArray.size()]; treeprops._thresholds = MemoryManager.malloc4f(sharedTreeSubgraph.nodesArray.size()); treeprops._features = new String[sharedTreeSubgraph.nodesArray.size()]; treeprops._nas = new String[sharedTreeSubgraph.nodesArray.size()]; treeprops._predictions = MemoryManager.malloc4f(sharedTreeSubgraph.nodesArray.size());
public AppendableVec[] vecs(){ if(_dout.length == 1) return _dout[0]._vecs; int nCols = 0; for(FVecDataOut dout:_dout) nCols = Math.max(dout._vecs.length,nCols); AppendableVec [] res = new AppendableVec[nCols]; int nchunks = 0; for(FVecDataOut dout:_dout) nchunks += dout.nChunks(); long [] espc = MemoryManager.malloc8(nchunks); for(int i = 0; i < res.length; ++i) { res[i] = new AppendableVec(_vg.vecKey(_vecIdStart + i), espc, 0); res[i]._chunkTypes = MemoryManager.malloc1(nchunks); } for(int i = 0; i < _dout.length; ++i) for(int j = 0; j < _dout[i]._vecs.length; ++j) res[j].setSubRange(_dout[i]._vecs[j]); return res; } public String _parserr; // NULL if parse is OK, else an error string
@Override protected void setupLocal() { _syn0 = MemoryManager.malloc4f(_wordVecSize * _vocabWordCount); _words = new BufferedString[_vocabWordCount]; }
private void append2slowUUID() { final int CHUNK_SZ = 1 << H2O.LOG_CHK; if( _sparseLen > CHUNK_SZ ) throw new ArrayIndexOutOfBoundsException(_sparseLen); if( _ds==null && _ls!=null ) { // This can happen for columns with all NAs and then a UUID _xs=null; alloc_doubles(_sparseLen); Arrays.fill(_ls,C16Chunk._LO_NA); Arrays.fill(_ds,Double.longBitsToDouble(C16Chunk._HI_NA)); } if( _ls != null && _ls.length > 0 ) { _ls = MemoryManager.arrayCopyOf(_ls,_sparseLen<<1); _ds = MemoryManager.arrayCopyOf(_ds,_sparseLen<<1); } else { alloc_mantissa(4); alloc_doubles(4); } assert _sparseLen == 0 || _ls.length > _sparseLen:"_ls.length = " + _ls.length + ", _sparseLen = " + _sparseLen; } // Slow-path append data
static double[][][] malloc3DArray(final int d1, final int d2, final int d3) { final double[][][] array = new double[d1][d2][]; for (int j = 0; j < d1; ++j) for (int k = 0; k < d2; ++k) array[j][k] = MemoryManager.malloc8d(d3); return array; }
@Override public void reduce(GetNonZerosTsk gnz){ if(_idxs.length + gnz._idxs.length > _maxsz) throw new RuntimeException("too many nonzeros! found at least " + (_idxs.length + gnz._idxs.length) + " nonzeros."); int [] idxs = MemoryManager.malloc4(_idxs.length + gnz._idxs.length); double [] vals = MemoryManager.malloc8d(_vals.length + gnz._vals.length); Utils.sortedMerge(_idxs,_vals,gnz._idxs,gnz._vals,idxs,vals); _idxs = idxs; _vals = vals; } }
@Override public void map(Chunk [] chunks){ _xvals = new GLMValidation[_xmodels.length]; for(int i = 0; i < _xmodels.length; ++i) _xvals[i] = new GLMValidation(null,_xmodels[i].glm,_xmodels[i].rank(),_thresholds); final int nrows = chunks[0]._len; long start = chunks[0]._start; double [] row = MemoryManager.malloc8d(_xmodels[0]._names.length); float [] preds = MemoryManager.malloc4f(_xmodels[0].glm.family == Family.binomial?3:1); OUTER: for(int i = 0; i < nrows; ++i){ if(chunks[chunks.length-1].isNA0(i))continue; for(int j = 0; j < chunks.length-1; ++j){ if(chunks[j].isNA0(i))continue OUTER; row[j] = chunks[j].at0(i); } ++_nobs; final int mid = (int)((i + start) % _xmodels.length); final GLMModel model = _xmodels[mid]; final GLMValidation val = _xvals[mid]; model.score0(row, preds); double response = chunks[chunks.length-1].at80(i); val.add(response, model.glm.family == Family.binomial?preds[2]:preds[0]); } } @Override public void reduce(GLMXValidationTask gval){
long [] alloc_mantissa(int l) { return _ls = MemoryManager.malloc8(l); } int [] alloc_exponent(int l) { return _xs = MemoryManager.malloc4(l); }
@Override public void setupLocal(){ res = MemoryManager.malloc4(N); } @Override public void map(Chunk c){