@Override void init0() { _sums = MemoryManager.malloc8(_nbin); }
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.
@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); }
long [] alloc_mantissa(int l) { return _ls = MemoryManager.malloc8(l); } int [] alloc_exponent(int l) { return _xs = MemoryManager.malloc4(l); }
@Override protected void chunkInit(){ final int n_time = _time.length * _num_strata; final int n_coef = _beta.length; sumWeights = MemoryManager.malloc8d(_num_strata); sumWeightedCatX = malloc2DArray(_num_strata, _dinfo.numCats()); sumWeightedNumX = malloc2DArray(_num_strata, _dinfo.numNums()); 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 = MemoryManager.malloc8d(n_coef); sumXRiskEvents = malloc2DArray(n_time, n_coef); rcumsumXRisk = malloc2DArray(n_time, n_coef); if (_isBreslow) { // Breslow only rcumsumXXRisk = malloc3DArray(n_time, n_coef, n_coef); } }
@Override public void setupLocal(){ super.setupLocal(); _espc = MemoryManager.malloc8(_nchunks); _visited = new NonBlockingSetInt(); } @Override public void map( Chunk in) {
@Override public void map(Chunk c) { _ids = MemoryManager.malloc8(_n); _vals = MemoryManager.malloc8d(_n); Arrays.fill(_vals,Double.POSITIVE_INFINITY); Arrays.fill(_ids,-1); for(int i = c.nextNZ(-1); i < c._len; i = c.nextNZ(i)) addVal(i + c._start,_rev?-c.at0(i):c.at0(i)); }
CHM( final NonBlockingHashMapLong nbhml, ConcurrentAutoTable size, final int logsize ) { _nbhml = nbhml; _size = size; _slots= new ConcurrentAutoTable(); _keys = water.MemoryManager.malloc8 (1<<logsize); _vals = water.MemoryManager.mallocObj(1<<logsize); }
time = MemoryManager.malloc8(n_time); n_risk = MemoryManager.malloc8d(n_time); n_event = MemoryManager.malloc8d(n_time);
long sums0[] = MemoryManager.malloc8(nbins+1); long ns0[] = MemoryManager.malloc8(nbins+1); for( int b=1; b<=nbins; b++ ) { long m0 = sums0[b-1], m1 = _sums[idx[b-1]]; long sums1[] = MemoryManager.malloc8(nbins+1); long ns1[] = MemoryManager.malloc8(nbins+1); for( int b=nbins-1; b>=0; b-- ) { long m0 = sums1[b+1], m1 = _sums[idx[b]];
public long[] getA8( ) { _arys++; // Get the lengths of lead & trailing zero sections, and the non-zero // middle section. int x = getInt(); if( x == -1 ) return null; int y = getInt(); // Non-zero in the middle int z = y==0 ? 0 : getInt();// Trailing zeros long[] buf = MemoryManager.malloc8(x+y+z); switch( get1() ) { // 1,2,4 or 8 for how the middle section is passed case 1: for( int i=x; i<x+y; i++ ) buf[i] = get1(); return buf; case 2: for( int i=x; i<x+y; i++ ) buf[i] = (short)get2(); return buf; case 4: for( int i=x; i<x+y; i++ ) buf[i] = get4(); return buf; case 8: break; default: throw H2O.fail(); } int sofar = x; while( sofar < x+y ) { LongBuffer as = _bb.asLongBuffer(); int more = Math.min(as.remaining(), x+y - sofar); as.get(buf, sofar, more); sofar += more; _bb.position(_bb.position() + as.position()*8); if( sofar < x+y ) getSp(Math.min(_bb.capacity()-7, (x+y-sofar)*8)); } return buf; } public double[] getA8d( ) {
long [] ls = MemoryManager.malloc8(nzeros); int [] xs = MemoryManager.malloc4(nzeros); for(int i = 0; i < _sparseLen; ++i){
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
double[] d9 = MemoryManager.malloc8d(1000); long[] c1 = MemoryManager.malloc8(1000); long[] c2 = MemoryManager.malloc8(1000); String[] dom = new String[]{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}; for (int i = 0; i < d1.length; ++i) {
private FVecDataOut makeDout(ParserSetup localSetup, int chunkOff, int nchunks) { AppendableVec [] avs = new AppendableVec[localSetup._ncols]; long [] espc = MemoryManager.malloc8(nchunks); for(int i = 0; i < avs.length; ++i) avs[i] = new AppendableVec(_vg.vecKey(i + _vecIdStart),espc, chunkOff); return localSetup._pType == ParserType.SVMLight ?new SVMLightFVecDataOut(_vg,chunkOff,avs,_vecIdStart,chunkOff,enums(_eKey,localSetup._ncols)) :new FVecDataOut(_vg, chunkOff, chunkOff, enums(_eKey,localSetup._ncols), avs); }
@Override protected void chunkInit(){ final int n_time = _time.length * _num_strata; final int n_coef = _beta.length; sumWeights = MemoryManager.malloc8d(_num_strata); sumWeightedCatX = malloc2DArray(_num_strata, _dinfo.numCats()); sumWeightedNumX = malloc2DArray(_num_strata, _dinfo.numNums()); 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 = MemoryManager.malloc8d(n_coef); sumXRiskEvents = malloc2DArray(n_time, n_coef); rcumsumXRisk = malloc2DArray(n_time, n_coef); if (_isBreslow) { // Breslow only rcumsumXXRisk = malloc3DArray(n_time, n_coef, n_coef); } }
@Override public void compute2() { long [] espc = MemoryManager.malloc8(_nChunks+1); int rpc = (int)(_vecs[0].length() / _nChunks); int rem = (int)(_vecs[0].length() % _nChunks);; Arrays.fill(espc, rpc); for (int i = 0; i < rem; ++i) ++espc[i]; long sum = 0; for (int i = 0; i < espc.length; ++i) { long s = espc[i]; espc[i] = sum; sum += s; } _newVecs = new Vec(Vec.newKey(),espc).makeZeros(_vecs.length); setPendingCount(_vecs.length-1); for(int i = 0; i < Math.min(_vecs.length,_maxP); ++i) { new RebalanceTask(new Cmp(), _vecs[i]).asyncExec(_newVecs[i]); } }
public Frame createMappingOfExemplars(Key destinationKey){ final long[] keep = MemoryManager.malloc8(_exemplars.length); for (int i=0;i<keep.length;++i) keep[i]=_exemplars[i].gid; Vec exAssignment = _exemplar_assignment_vec_key.get(); Arrays.sort(keep); Vec exemplarAssignment = new MRTask() { @Override public void map(Chunk c1, NewChunk nc) { for (int i = 0; i < c1._len; i++) { long gid = c1.at8(i); nc.addNum(ArrayUtils.find(keep, gid)); } } }.doAll(Vec.T_NUM,exAssignment).outputFrame().vec(0); Frame mapping = new Frame(destinationKey,new String[]{"exemplar_assignment"}, new Vec[]{exemplarAssignment}); final long[] uniqueExemplars = new VecUtils.CollectIntegerDomain().doAll(mapping.vecs()).domain(); assert(uniqueExemplars.length==_exemplars.length); assert(mapping.numRows()==exAssignment.length()); for(long exmp: uniqueExemplars){ assert(exmp <= _exemplars.length); } DKV.put(mapping); return mapping; }
static Object select( long len, AST ast, Env env ) { if( ast == null ) return null; // Trivial "all" ast.exec(env); long cols[]; if( !env.isAry() ) { int col = (int)env._d[env._sp-1]; // Peek double; Silent truncation (R semantics) if( col < 0 && col < -len ) col=0; // Ignore a non-existent column if( col == 0 ) return new long[0]; return new long[]{col}; } // Got a frame/list of results. // Decide if we're a toss-out or toss-in list Frame ary = env._ary[env._sp-1]; // Peek-frame if( ary.numCols() != 1 ) throw new IllegalArgumentException("Selector must be a single column: "+ary.toStringNames()); Vec vec = ary.anyVec(); // Check for a matching column of bools. if( ary.numRows() == len && vec.min()>=0 && vec.max()<=1 && vec.isInt() && ary.numRows() > 1) return ary; // Boolean vector selection. // Convert single vector to a list of longs selecting rows if(ary.numRows() > 10000000) throw H2O.fail("Unimplemented: Cannot explicitly select > 10000000 rows in slice."); cols = MemoryManager.malloc8((int)ary.numRows()); for(int i = 0; i < cols.length; ++i){ if(vec.isNA(i))throw new IllegalArgumentException("Can not use NA as index!"); cols[i] = vec.at8(i); } return cols; }