@Override public INormalizedKeyProperties getNormalizedKeyProperties() { return nkc.getNormalizedKeyProperties(); } };
@Override public void normalize(byte[] bytes, int start, int length, int[] normalizedKeys, int keyStart) { // normalize msb nkc.normalize(bytes, start, length, normalizedKeys, keyStart); // normalize lsb nkc.normalize(bytes, start + Long.BYTES, length - Long.BYTES, normalizedKeys, keyStart + int64NormalizedKeyLength); }
@Override public INormalizedKeyProperties getNormalizedKeyProperties() { return nkc.getNormalizedKeyProperties(); } };
@Override public void normalize(byte[] bytes, int start, int length, int[] normalizedKeys, int keyStart) { nkc.normalize(bytes, start + 1, length - 1, normalizedKeys, keyStart); for (int i = 0; i < normalizedKeyLength; i++) { int key = normalizedKeys[keyStart + i]; normalizedKeys[keyStart + i] = ~key; } }
public static int[] createNormalizedKeyArray(INormalizedKeyComputer normalizer) { if (normalizer == null) { return null; //NOSONAR } return new int[normalizer.getNormalizedKeyProperties().getNormalizedKeyLength()]; }
@Override public void normalize(byte[] bytes, int start, int length, int[] normalizedKeys, int keyStart) { // start +1, length -1 is because in ASTERIX data format, there is always a type tag before the value nkc.normalize(bytes, start + 1, length - 1, normalizedKeys, keyStart); }
public RunMergingFrameReader(IHyracksTaskContext ctx, List<? extends IFrameReader> runs, List<? extends IFrame> inFrames, int[] sortFields, IBinaryComparator[] comparators, INormalizedKeyComputer nmkComputer, RecordDescriptor recordDesc, int topK) { this.ctx = ctx; this.runCursors = runs; this.inFrames = inFrames; this.sortFields = sortFields; this.comparators = comparators; this.nmkComputer = nmkComputer; this.normalizedKeyLength = nmkComputer != null ? nmkComputer.getNormalizedKeyProperties().getNormalizedKeyLength() : 0; // right now we didn't take multiple key normalizers for frame merger, since during this step it won't be // too many cache misses (merging multiple runs sequentially). // but still, we can apply a special optimization if there is only 1 sort field this.normalizedKeyDecisive = nmkComputer != null ? nmkComputer.getNormalizedKeyProperties().isDecisive() && comparators.length == 1 : false; this.recordDesc = recordDesc; this.topK = topK; }
private void getFirstNorm(int inputId1, FrameTupleAccessor frameTupleAccessor1, int tid1, int[] keys) { if (firstKeyNormalizerComputer != null) { firstKeyNormalizerComputer.normalize(frameTupleAccessor1.getBuffer().array(), frameTupleAccessor1.getAbsoluteFieldStartOffset(tid1, compareFields[inputId1][0]), frameTupleAccessor1.getFieldLength(tid1, compareFields[inputId1][0]), keys, 0); } }
public ReferenceEntry(int runid, FrameTupleAccessor fta, int tupleIndex, int[] keyFields, INormalizedKeyComputer nmkComputer) { super(); this.runid = runid; this.acccessor = fta; this.normalizedKeyLength = nmkComputer != null ? nmkComputer.getNormalizedKeyProperties().getNormalizedKeyLength() : 0; this.tPointers = new int[normalizedKeyLength + 2 * keyFields.length]; if (fta != null) { initTPointer(fta, tupleIndex, keyFields, nmkComputer); } }
private int[] getPNK(IFrameTupleAccessor fta, int tIx) { if (nkcs == null) { return nmk; } int keyPos = 0; byte[] buffer = fta.getBuffer().array(); for (int i = 0; i < nkcs.length; i++) { int sfIdx = sortFields[i]; nkcs[i].normalize(buffer, fta.getAbsoluteFieldStartOffset(tIx, sfIdx), fta.getFieldLength(tIx, sfIdx), nmk, keyPos); keyPos += normalizedKeyLength[i]; } return nmk; }
private void initTPointer(IFrameTupleAccessor fta, int tupleIndex, int[] keyFields, INormalizedKeyComputer nmkComputer) { this.tupleIndex = tupleIndex; byte[] b1 = fta.getBuffer().array(); for (int f = 0; f < keyFields.length; ++f) { int fIdx = keyFields[f]; tPointers[2 * f + normalizedKeyLength] = fta.getAbsoluteFieldStartOffset(tupleIndex, fIdx); tPointers[2 * f + normalizedKeyLength + 1] = fta.getFieldLength(tupleIndex, fIdx); if (f == 0 && nmkComputer != null) { nmkComputer.normalize(b1, tPointers[normalizedKeyLength], tPointers[normalizedKeyLength + 1], tPointers, 0); } } } }
int fieldEndOffsetRel = inputTupleAccessor.getFieldEndOffset(j, sortField); int fieldStartOffset = fieldStartOffsetRel + tStart + fieldSlotsLength; nkcs[k].normalize(array, fieldStartOffset, fieldEndOffsetRel - fieldStartOffsetRel, tPointers, keyPos); keyPos += normalizedKeyLength[k];