Refine search
public DoublePointer asDoublePointer() { return new DoublePointer(this); }
/** * @param doublePointer * @param length * @return */ @Override public DataBuffer create(DoublePointer doublePointer, long length) { doublePointer.capacity(length); doublePointer.limit(length); doublePointer.position(0); return new DoubleBuffer(doublePointer, DoubleIndexer.create(doublePointer), length); }
/** Constructor to set the {@link #pointer}, {@link #sizes} and {@link #strides}. */ public DoubleRawIndexer(DoublePointer pointer, long[] sizes, long[] strides) { super(sizes, strides); this.pointer = pointer; base = pointer.address() + pointer.position() * VALUE_BYTES; size = pointer.limit() - pointer.position(); }
@Override protected void dsyrk(char Order, char Uplo, char Trans, int N, int K, double alpha, INDArray A, int lda, double beta, INDArray C, int ldc) { if (Nd4j.dataType() != DataBuffer.Type.DOUBLE) logger.warn("DOUBLE syrk called"); Nd4j.getExecutioner().push(); CudaContext ctx = allocator.getFlowController().prepareAction(C, A); CublasPointer aPointer = new CublasPointer(A, ctx); CublasPointer cPointer = new CublasPointer(C, ctx); cublasHandle_t handle = ctx.getHandle(); synchronized (handle) { cublasSetStream_v2(new cublasContext(handle), new CUstream_st(ctx.getOldStream())); cublasDsyrk_v2(new cublasContext(handle), convertUplo(Uplo), Trans, N, K, new DoublePointer(alpha), (DoublePointer) aPointer.getDevicePointer(), lda, new DoublePointer(beta), (DoublePointer) cPointer.getDevicePointer(), ldc); } allocator.registerAction(ctx, C, A); OpExecutionerUtil.checkForAny(C); }
/** * Create a data buffer from * the given length * * @param buffer * @param length */ public BaseDataBuffer(ByteBuffer buffer, long length) { if (length < 1) throw new IllegalArgumentException("Length must be >= 1"); initTypeAndSize(); this.length = length; allocationMode = AllocUtil.getAllocationModeFromContext(); if (dataType() == Type.DOUBLE) { pointer = new DoublePointer(buffer.asDoubleBuffer()); setIndexer(DoubleIndexer.create((DoublePointer) pointer)); } else if (dataType() == Type.FLOAT) { pointer = new FloatPointer(buffer.asFloatBuffer()); setIndexer(FloatIndexer.create((FloatPointer) pointer)); } else if (dataType() == Type.INT) { pointer = new IntPointer(buffer.asIntBuffer()); setIndexer(IntIndexer.create((IntPointer) pointer)); } else if (dataType() == Type.LONG) { pointer = new LongPointer(buffer.asLongBuffer()); setIndexer(LongIndexer.create((LongPointer) pointer)); } // log.info("Creating new buffer of size: {}; dtype: {}; D", length, dataType()); }
DoublePointer pointer = new DoublePointer(data); Pointer srcPtr = new CudaPointer(pointer.address() + (dstOffset * elementSize)); pointer.address(); } else if (dataType() == Type.FLOAT) { FloatPointer pointer = new FloatPointer(ArrayUtil.toFloats(data)); Pointer srcPtr = new CudaPointer(pointer.address() + (dstOffset * elementSize)); pointer.address(); } else if (dataType() == Type.INT) { IntPointer pointer = new IntPointer(ArrayUtil.toInts(data)); Pointer srcPtr = new CudaPointer(pointer.address() + (dstOffset * elementSize)); pointer.address(); } else if (dataType() == Type.HALF) { ShortPointer pointer = new ShortPointer(ArrayUtil.toHalfs(data));
Nd4j.getExecutioner().commit(); op.addOutputArgument(Nd4j.create(shape)); val dtype = Nd4j.dataType(); if (Nd4j.dataType() == DataBuffer.Type.FLOAT) { val tArgs = op.tArgs().length > 0 ? new FloatPointer(op.tArgs().length) : null; tArgs.put(cnt++, (float) t); throw new ND4JIllegalStateException("Op execution failed: " + status); } else if (Nd4j.dataType() == DataBuffer.Type.DOUBLE) { val tArgs = op.tArgs().length > 0 ? new DoublePointer(op.tArgs().length) : null; tArgs.put(cnt++, t);
shapeBufferPointer.position(0); IntPointer intPointer = new IntPointer(shapeBufferPointer); DataBuffer shapeBuffer = Nd4j.createBuffer(shapeBufferPointer, DataBuffer.Type.INT,length, IntIndexer.create(intPointer)); data = Nd4j.createBuffer(dataPointer, DataBuffer.Type.FLOAT, Shape.length(shapeBuffer), FloatIndexer.create(new FloatPointer(dataPointer))); data = Nd4j.createBuffer(dataPointer, DataBuffer.Type.DOUBLE, Shape.length(shapeBuffer), DoubleIndexer.create(new DoublePointer(dataPointer)));
IntBuffer b = (IntBuffer)samples[i]; if (samples_in[i] instanceof IntPointer && samples_in[i].capacity() >= inputSize && b.hasArray()) { ((IntPointer)samples_in[i]).position(0).put(b.array(), samples[i].position(), inputSize); } else { samples_in[i] = new IntPointer(b); FloatBuffer b = (FloatBuffer)samples[i]; if (samples_in[i] instanceof FloatPointer && samples_in[i].capacity() >= inputSize && b.hasArray()) { ((FloatPointer)samples_in[i]).position(0).put(b.array(), b.position(), inputSize); } else { samples_in[i] = new FloatPointer(b); DoubleBuffer b = (DoubleBuffer)samples[i]; if (samples_in[i] instanceof DoublePointer && samples_in[i].capacity() >= inputSize && b.hasArray()) { ((DoublePointer)samples_in[i]).position(0).put(b.array(), b.position(), inputSize); } else { samples_in[i] = new DoublePointer(b);
@Override protected double dnrm2(long N, INDArray X, int incX) { if (Nd4j.dataType() != DataBuffer.Type.DOUBLE) logger.warn("DOUBLE nrm2 called"); Nd4j.getExecutioner().push(); double ret; CudaContext ctx = allocator.getFlowController().prepareAction(null, X); CublasPointer cAPointer = new CublasPointer(X, ctx); cublasHandle_t handle = ctx.getHandle(); synchronized (handle) { cublasSetStream_v2(new cublasContext(handle), new CUstream_st(ctx.getOldStream())); DoublePointer resultPointer = new DoublePointer(0.0f); cublasDnrm2_v2(new cublasContext(handle), (int) N, (DoublePointer) cAPointer.getDevicePointer(), incX, resultPointer); ret = resultPointer.get(); } allocator.registerAction(ctx, null, X); return ret; }
int intArraysPos = indexPos + (batch.getSample().maxIndexArguments() * (Batch.getBatchLimit() * 16)); int realPos = (intArraysPos + (maxIntArrays * maxArraySize * (Batch.getBatchLimit() * 16))) / (Nd4j.dataType() == DataBuffer.Type.DOUBLE ? 2 : 1); if (Nd4j.dataType() == DataBuffer.Type.HALF) realPos *= 2; / (Nd4j.dataType() == DataBuffer.Type.FLOAT ? 2 : 1); if (Nd4j.dataType() == DataBuffer.Type.HALF) pointer.put(idx, op.getArguments().size()); pointer.put(idx + 1, op.getShapes().size()); pointer.put(idx + 2, op.getIndexingArguments().size()); pointer.put(idx + 3, op.getRealArguments().size()); pointer.put(idx + 4, op.getIntArrayArguments().size()); } else if (Nd4j.dataType() == DataBuffer.Type.DOUBLE) { DoublePointer dPtr = new DoublePointer(pointer); for (int e = 0; e < op.getRealArguments().size(); e++) { idx = realPos + (i * op.maxRealArguments()); dPtr.put(idx + e, op.getRealArguments().get(e).doubleValue()); } else if (Nd4j.dataType() == DataBuffer.Type.HALF) {
/** Returns {@link #tensor_data()} wrapped in a {@link Buffer} of appropriate type starting at given index. */ public <B extends Buffer> B createBuffer(long index) { BytePointer ptr = tensor_data(); long size = TotalBytes(); switch (dtype()) { case DT_COMPLEX64: case DT_FLOAT: return (B)new FloatPointer(ptr).position(index).capacity(size/4).asBuffer(); case DT_DOUBLE: return (B)new DoublePointer(ptr).position(index).capacity(size/8).asBuffer(); case DT_QINT32: case DT_INT32: return (B)new IntPointer(ptr).position(index).capacity(size/4).asBuffer(); case DT_BOOL: case DT_QUINT8: case DT_UINT8: case DT_QINT8: case DT_INT8: return (B)ptr.position(index).capacity(size).asBuffer(); case DT_BFLOAT16: case DT_INT16: return (B)new ShortPointer(ptr).position(index).capacity(size/2).asBuffer(); case DT_INT64: return (B)new LongPointer(ptr).position(index).capacity(size/8).asBuffer(); case DT_STRING: default: assert false; } return null; }
@Override public List<long[]> calculateOutputShape(@NonNull CustomOp op) { Nd4j.getExecutioner().commit(); iArgs.put(cnt++, i); if (Nd4j.dataType() == DataBuffer.Type.FLOAT) { val tArgs = op.tArgs().length > 0 ? new FloatPointer(op.tArgs().length) : null; tArgs.put(cnt++, (float) t); } else if (Nd4j.dataType() == DataBuffer.Type.DOUBLE) { val tArgs = op.tArgs().length > 0 ? new DoublePointer(op.tArgs().length) : null; tArgs.put(cnt++, (float) t);
case DT_FLOAT: return (I)FloatIndexer.create(new FloatPointer(ptr).capacity(size/4), sizes, strides, direct).indexable(this); case DT_DOUBLE: return (I)DoubleIndexer.create(new DoublePointer(ptr).capacity(size/8), sizes, strides, direct).indexable(this); case DT_QINT32: case DT_INT32: return (I)IntIndexer.create(new IntPointer(ptr).capacity(size/4), sizes, strides, direct).indexable(this); case DT_BOOL: case DT_QUINT8:
sampleFormat = data.length > 1 ? AV_SAMPLE_FMT_S32P : AV_SAMPLE_FMT_S32; for (int i = 0; i < data.length; i++) { data[i] = new IntPointer((IntBuffer)samples[i]); data[i] = new FloatPointer((FloatBuffer)samples[i]); data[i] = new DoublePointer((DoubleBuffer)samples[i]);
/** * This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines * * @param data * @param shape * @param order * @return */ @Override public INDArray compress(double[] data, int[] shape, char order) { DoublePointer pointer = new DoublePointer(data); DataBuffer shapeInfo = Nd4j.getShapeInfoProvider().createShapeInformation(shape, order).getFirst(); DataBuffer buffer = compressPointer(DataBuffer.TypeEx.DOUBLE, pointer, data.length, 8); return Nd4j.createArrayFromShapeBuffer(buffer, shapeInfo); }
/** * * @param data * @param copy */ public BaseDataBuffer(double[] data, boolean copy) { allocationMode = AllocUtil.getAllocationModeFromContext(); initTypeAndSize(); pointer = new DoublePointer(data); indexer = DoubleIndexer.create((DoublePointer) pointer); //wrappedBuffer = pointer.asByteBuffer(); length = data.length; underlyingLength = data.length; }