8666

Build # 8666

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/3f72ac2e6ef1a8c0537feb9de826ccfd858d1513">3f72ac2e6<a href="https://github.com/apache/carbondata/commit/3f72ac2e6ef1a8c0537feb9de826ccfd858d1513">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/f9a08d2dd7145ca4ead6600b10381fd9d547358d">f9a08d2dd</a>">f9a08d2dd</a><a href="https://github.com/apache/carbondata/commit/3f72ac2e6ef1a8c0537feb9de826ccfd858d1513"> into 8320918e5">8320918e5</a>

Run Details

4 of 4 new or added lines in 2 files covered. (100.0%)

59756 of 74217 relevant lines covered (80.52%)

1.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.5

/core/src/main/java/org/apache/carbondata/core/datastore/chunk/store/impl/unsafe/UnsafeAbstractDimensionDataChunkStore.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.carbondata.core.datastore.chunk.store.impl.unsafe;

import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datastore.chunk.store.DimensionDataChunkStore;
import org.apache.carbondata.core.memory.CarbonUnsafe;
import org.apache.carbondata.core.memory.MemoryBlock;
import org.apache.carbondata.core.memory.MemoryException;
import org.apache.carbondata.core.memory.UnsafeMemoryManager;
import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
import org.apache.carbondata.core.util.ThreadLocalTaskInfo;

/**
 * Responsibility is to store dimension data in memory. storage can be on heap
 * or offheap.
 */
public abstract class UnsafeAbstractDimensionDataChunkStore implements DimensionDataChunkStore {

  /**
   * memory block for data page
   */
  protected MemoryBlock dataPageMemoryBlock;

  /**
   * to check whether dimension column was explicitly sorted or not
   */
  protected boolean isExplicitSorted;

  /**
   * is memory released
   */
  protected boolean isMemoryReleased;

  /**
   * length of the actual data
   */
  protected int dataLength;

  /**
   * offset of the inverted index reverse
   */
  protected long invertedIndexReverseOffset;

  /**
   * to validate whether data is already kept in memory or not
   */
  protected boolean isMemoryOccupied;

  private final long taskId = ThreadLocalTaskInfo.getCarbonTaskInfo().getTaskId();

  /**
   * Constructor
   *
   * @param totalSize      total size of the data to be kept
   * @param isInvertedIdex is inverted index present
   * @param numberOfRows   total number of rows
   */
  public UnsafeAbstractDimensionDataChunkStore(long totalSize, boolean isInvertedIdex,
      int numberOfRows) {
    try {
      // allocating the data page
      this.dataPageMemoryBlock = UnsafeMemoryManager.allocateMemoryWithRetry(taskId, totalSize);
    } catch (MemoryException e) {
      throw new RuntimeException(e);
    }
    this.isExplicitSorted = isInvertedIdex;
  }

  /**
   * Below method will be used to put the rows and its metadata in offheap
   *
   * @param invertedIndex        inverted index to be stored
   * @param invertedIndexReverse inverted index reverse to be stored
   * @param data                 data to be stored
   */
  @Override public void putArray(final int[] invertedIndex, final int[] invertedIndexReverse,
      final byte[] data) {
    assert (!isMemoryOccupied);
    this.dataLength = data.length;
    this.invertedIndexReverseOffset = dataLength;
    if (isExplicitSorted) {
      this.invertedIndexReverseOffset +=
          invertedIndex.length * CarbonCommonConstants.INT_SIZE_IN_BYTE;
    }
    // copy the data to memory
    CarbonUnsafe.getUnsafe()
        .copyMemory(data, CarbonUnsafe.BYTE_ARRAY_OFFSET, dataPageMemoryBlock.getBaseObject(),
            dataPageMemoryBlock.getBaseOffset(), this.dataLength);
    // if inverted index is present then copy the inverted index
    // and reverse inverted index to memory
    if (isExplicitSorted) {
      CarbonUnsafe.getUnsafe().copyMemory(invertedIndex, CarbonUnsafe.INT_ARRAY_OFFSET,
          dataPageMemoryBlock.getBaseObject(), dataPageMemoryBlock.getBaseOffset() + dataLength,
          invertedIndex.length * CarbonCommonConstants.INT_SIZE_IN_BYTE);
      CarbonUnsafe.getUnsafe().copyMemory(invertedIndexReverse, CarbonUnsafe.INT_ARRAY_OFFSET,
          dataPageMemoryBlock.getBaseObject(),
          dataPageMemoryBlock.getBaseOffset() + this.invertedIndexReverseOffset,
          invertedIndexReverse.length * CarbonCommonConstants.INT_SIZE_IN_BYTE);
    }
  }

  /**
   * Below method will be used to free the memory occupied by the column chunk
   */
  @Override public void freeMemory() {
    if (isMemoryReleased) {
      return;
    }
    // free data page memory
    UnsafeMemoryManager.INSTANCE.freeMemory(taskId, dataPageMemoryBlock);
    isMemoryReleased = true;
    this.dataPageMemoryBlock = null;
    this.isMemoryOccupied = false;
  }

  /**
   * Below method will be used to get the inverted index
   *
   * @param rowId row id
   * @return inverted index based on row id passed
   */
  @Override public int getInvertedIndex(int rowId) {
    return CarbonUnsafe.getUnsafe().getInt(dataPageMemoryBlock.getBaseObject(),
        dataPageMemoryBlock.getBaseOffset() + dataLength + ((long)rowId
            * CarbonCommonConstants.INT_SIZE_IN_BYTE));
  }

  /**
   * Below method will be used to get the reverse inverted index
   *
   * @param rowId row id
   * @return inverted index based on row id passed
   */
  @Override public int getInvertedReverseIndex(int rowId) {
    return CarbonUnsafe.getUnsafe().getInt(dataPageMemoryBlock.getBaseObject(),
        dataPageMemoryBlock.getBaseOffset() + this.invertedIndexReverseOffset + ((long)rowId
            * CarbonCommonConstants.INT_SIZE_IN_BYTE));
  }

  /**
   * Below method will be used to get the surrogate key of the based on the row
   * id passed
   *
   * @param rowId row id
   * @return surrogate key
   */
  @Override public int getSurrogate(int rowId) {
    throw new UnsupportedOperationException("Operation not supported");
  }

  /**
   * @return size of each column value
   */
  @Override public int getColumnValueSize() {
    throw new UnsupportedOperationException("Operation not supported");
  }

  /**
   * @return whether column was explicitly sorted or not
   */
  @Override public boolean isExplicitSorted() {
    return isExplicitSorted;
  }

  /**
   * Below method will be used to fill the row values to data array
   *
   * @param rowId  row id of the data to be filled
   * @param data   buffer in which data will be filled
   * @param offset off the of the buffer
   */
  @Override public void fillRow(int rowId, byte[] data, int offset) {
    throw new UnsupportedOperationException("Operation not supported");
  }

  @Override public void fillRow(int rowId, CarbonColumnVector vector, int vectorRow) {
    throw new UnsupportedOperationException("Operation not supported");
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.carbondata.core.datastore.chunk.store.impl.unsafe;
19
20	import org.apache.carbondata.core.constants.CarbonCommonConstants;
21	import org.apache.carbondata.core.datastore.chunk.store.DimensionDataChunkStore;
22	import org.apache.carbondata.core.memory.CarbonUnsafe;
23	import org.apache.carbondata.core.memory.MemoryBlock;
24	import org.apache.carbondata.core.memory.MemoryException;
25	import org.apache.carbondata.core.memory.UnsafeMemoryManager;
26	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
27	import org.apache.carbondata.core.util.ThreadLocalTaskInfo;
28
29	/**
30	* Responsibility is to store dimension data in memory. storage can be on heap
31	* or offheap.
32	*/
33	public abstract class UnsafeAbstractDimensionDataChunkStore implements DimensionDataChunkStore {	2✔
34
35	/**
36	* memory block for data page
37	*/
38	protected MemoryBlock dataPageMemoryBlock;
39
40	/**
41	* to check whether dimension column was explicitly sorted or not
42	*/
43	protected boolean isExplicitSorted;
44
45	/**
46	* is memory released
47	*/
48	protected boolean isMemoryReleased;
49
50	/**
51	* length of the actual data
52	*/
53	protected int dataLength;
54
55	/**
56	* offset of the inverted index reverse
57	*/
58	protected long invertedIndexReverseOffset;
59
60	/**
61	* to validate whether data is already kept in memory or not
62	*/
63	protected boolean isMemoryOccupied;
64
65	private final long taskId = ThreadLocalTaskInfo.getCarbonTaskInfo().getTaskId();	2✔
66
67	/**
68	* Constructor
69	*
70	* @param totalSize total size of the data to be kept
71	* @param isInvertedIdex is inverted index present
72	* @param numberOfRows total number of rows
73	*/
74	public UnsafeAbstractDimensionDataChunkStore(long totalSize, boolean isInvertedIdex,
75	int numberOfRows) {	2✔
76	try {
77	// allocating the data page
78	this.dataPageMemoryBlock = UnsafeMemoryManager.allocateMemoryWithRetry(taskId, totalSize);	2✔
79	} catch (MemoryException e) {	×
80	throw new RuntimeException(e);	×
81	}	2✔
82	this.isExplicitSorted = isInvertedIdex;	2✔
83	}	2✔
84
85	/**
86	* Below method will be used to put the rows and its metadata in offheap
87	*
88	* @param invertedIndex inverted index to be stored
89	* @param invertedIndexReverse inverted index reverse to be stored
90	* @param data data to be stored
91	*/
92	@Override public void putArray(final int[] invertedIndex, final int[] invertedIndexReverse,
93	final byte[] data) {
94	assert (!isMemoryOccupied);	2✔
95	this.dataLength = data.length;	2✔
96	this.invertedIndexReverseOffset = dataLength;	2✔
97	if (isExplicitSorted) {	2✔
98	this.invertedIndexReverseOffset +=	2✔
99	invertedIndex.length * CarbonCommonConstants.INT_SIZE_IN_BYTE;
100	}
101	// copy the data to memory
102	CarbonUnsafe.getUnsafe()	2✔
103	.copyMemory(data, CarbonUnsafe.BYTE_ARRAY_OFFSET, dataPageMemoryBlock.getBaseObject(),	2✔
104	dataPageMemoryBlock.getBaseOffset(), this.dataLength);	2✔
105	// if inverted index is present then copy the inverted index
106	// and reverse inverted index to memory
107	if (isExplicitSorted) {	2✔
108	CarbonUnsafe.getUnsafe().copyMemory(invertedIndex, CarbonUnsafe.INT_ARRAY_OFFSET,	2✔
109	dataPageMemoryBlock.getBaseObject(), dataPageMemoryBlock.getBaseOffset() + dataLength,	2✔
110	invertedIndex.length * CarbonCommonConstants.INT_SIZE_IN_BYTE);
111	CarbonUnsafe.getUnsafe().copyMemory(invertedIndexReverse, CarbonUnsafe.INT_ARRAY_OFFSET,	2✔
112	dataPageMemoryBlock.getBaseObject(),	2✔
113	dataPageMemoryBlock.getBaseOffset() + this.invertedIndexReverseOffset,	2✔
114	invertedIndexReverse.length * CarbonCommonConstants.INT_SIZE_IN_BYTE);
115	}
116	}	2✔
117
118	/**
119	* Below method will be used to free the memory occupied by the column chunk
120	*/
121	@Override public void freeMemory() {
122	if (isMemoryReleased) {	1✔
123	return;	×
124	}
125	// free data page memory
126	UnsafeMemoryManager.INSTANCE.freeMemory(taskId, dataPageMemoryBlock);	1✔
127	isMemoryReleased = true;	1✔
128	this.dataPageMemoryBlock = null;	1✔
129	this.isMemoryOccupied = false;	1✔
130	}	1✔
131
132	/**
133	* Below method will be used to get the inverted index
134	*
135	* @param rowId row id
136	* @return inverted index based on row id passed
137	*/
138	@Override public int getInvertedIndex(int rowId) {
139	return CarbonUnsafe.getUnsafe().getInt(dataPageMemoryBlock.getBaseObject(),	1✔
140	dataPageMemoryBlock.getBaseOffset() + dataLength + ((long)rowId	1✔
141	* CarbonCommonConstants.INT_SIZE_IN_BYTE));
142	}
143
144	/**
145	* Below method will be used to get the reverse inverted index
146	*
147	* @param rowId row id
148	* @return inverted index based on row id passed
149	*/
150	@Override public int getInvertedReverseIndex(int rowId) {
151	return CarbonUnsafe.getUnsafe().getInt(dataPageMemoryBlock.getBaseObject(),	×
152	dataPageMemoryBlock.getBaseOffset() + this.invertedIndexReverseOffset + ((long)rowId	×
153	* CarbonCommonConstants.INT_SIZE_IN_BYTE));
154	}
155
156	/**
157	* Below method will be used to get the surrogate key of the based on the row
158	* id passed
159	*
160	* @param rowId row id
161	* @return surrogate key
162	*/
163	@Override public int getSurrogate(int rowId) {
164	throw new UnsupportedOperationException("Operation not supported");	×
165	}
166
167	/**
168	* @return size of each column value
169	*/
170	@Override public int getColumnValueSize() {
171	throw new UnsupportedOperationException("Operation not supported");	×
172	}
173
174	/**
175	* @return whether column was explicitly sorted or not
176	*/
177	@Override public boolean isExplicitSorted() {
178	return isExplicitSorted;	1✔
179	}
180
181	/**
182	* Below method will be used to fill the row values to data array
183	*
184	* @param rowId row id of the data to be filled
185	* @param data buffer in which data will be filled
186	* @param offset off the of the buffer
187	*/
188	@Override public void fillRow(int rowId, byte[] data, int offset) {
189	throw new UnsupportedOperationException("Operation not supported");	×
190	}
191
192	@Override public void fillRow(int rowId, CarbonColumnVector vector, int vectorRow) {
193	throw new UnsupportedOperationException("Operation not supported");	×
194	}
195	}

apache / carbondata / 8666

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous