11933

Build # 11933

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/e0f9cc0e9cb33c7ecc03d82e20796279b2efd011">e0f9cc0e9<a href="https://github.com/apache/carbondata/commit/e0f9cc0e9cb33c7ecc03d82e20796279b2efd011">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/7d551381284df1ac47e7b52c0d88b55de21ae439">7d5513812</a>">7d5513812</a><a href="https://github.com/apache/carbondata/commit/e0f9cc0e9cb33c7ecc03d82e20796279b2efd011"> into 2fb923450">2fb923450</a>

Run Details

620 of 620 new or added lines in 34 files covered. (100.0%)

64739 of 83248 relevant lines covered (77.77%)

1.02 hits per line

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

86.58

/core/src/main/java/org/apache/carbondata/core/indexstore/BlockletDataMapIndexStore.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.indexstore;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.cache.Cache;
import org.apache.carbondata.core.cache.CarbonLRUCache;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datamap.dev.DataMap;
import org.apache.carbondata.core.datastore.block.SegmentPropertiesAndSchemaHolder;
import org.apache.carbondata.core.indexstore.blockletindex.BlockDataMap;
import org.apache.carbondata.core.indexstore.blockletindex.BlockletDataMapFactory;
import org.apache.carbondata.core.indexstore.blockletindex.BlockletDataMapModel;
import org.apache.carbondata.core.indexstore.blockletindex.SegmentIndexFileStore;
import org.apache.carbondata.core.memory.MemoryException;
import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
import org.apache.carbondata.core.metadata.schema.table.CarbonTable;
import org.apache.carbondata.core.util.BlockletDataMapUtil;

import org.apache.hadoop.conf.Configuration;
import org.apache.log4j.Logger;

/**
 * Class to handle loading, unloading,clearing,storing of the table
 * blocks
 */
public class BlockletDataMapIndexStore
    implements Cache<TableBlockIndexUniqueIdentifierWrapper, BlockletDataMapIndexWrapper> {
  private static final Logger LOGGER =
      LogServiceFactory.getLogService(BlockletDataMapIndexStore.class.getName());
  /**
   * CarbonLRU cache
   */
  protected CarbonLRUCache lruCache;

  /**
   * map of block info to lock object map, while loading the btree this will be filled
   * and removed after loading the tree for that particular block info, this will be useful
   * while loading the tree concurrently so only block level lock will be applied another
   * block can be loaded concurrently
   */
  private Map<String, Object> segmentLockMap;

  /**
   * constructor to initialize the SegmentTaskIndexStore
   *
   * @param lruCache
   */
  public BlockletDataMapIndexStore(CarbonLRUCache lruCache) {
    this.lruCache = lruCache;
    segmentLockMap = new ConcurrentHashMap<String, Object>();
  }

  @Override
  public BlockletDataMapIndexWrapper get(TableBlockIndexUniqueIdentifierWrapper identifierWrapper)
      throws IOException {
    return get(identifierWrapper, null);
  }

  private BlockletDataMapIndexWrapper get(TableBlockIndexUniqueIdentifierWrapper identifierWrapper,
      Map<String, Map<String, BlockMetaInfo>> segInfoCache) throws IOException {
    TableBlockIndexUniqueIdentifier identifier =
        identifierWrapper.getTableBlockIndexUniqueIdentifier();
    String lruCacheKey = identifier.getUniqueTableSegmentIdentifier();
    BlockletDataMapIndexWrapper blockletDataMapIndexWrapper =
        (BlockletDataMapIndexWrapper) lruCache.get(lruCacheKey);
    List<BlockDataMap> dataMaps = new ArrayList<>();
    if (blockletDataMapIndexWrapper == null) {
      try {
        SegmentIndexFileStore indexFileStore =
            new SegmentIndexFileStore(identifierWrapper.getConfiguration());
        Set<String> filesRead = new HashSet<>();
        String segmentFilePath = identifier.getIndexFilePath();
        if (segInfoCache == null) {
          segInfoCache = new HashMap<>();
        }
        Map<String, BlockMetaInfo> carbonDataFileBlockMetaInfoMapping =
            segInfoCache.get(segmentFilePath);
        if (carbonDataFileBlockMetaInfoMapping == null) {
          carbonDataFileBlockMetaInfoMapping =
              BlockletDataMapUtil.createCarbonDataFileBlockMetaInfoMapping(segmentFilePath,
                  identifierWrapper.getConfiguration());
          segInfoCache.put(segmentFilePath, carbonDataFileBlockMetaInfoMapping);
        }
        // if the identifier is not a merge file we can directly load the datamaps
        if (identifier.getMergeIndexFileName() == null) {
          List<DataFileFooter> indexInfos = new ArrayList<>();
          Map<String, BlockMetaInfo> blockMetaInfoMap = BlockletDataMapUtil
              .getBlockMetaInfoMap(identifierWrapper, indexFileStore, filesRead,
                  carbonDataFileBlockMetaInfoMapping, indexInfos);
          BlockDataMap blockletDataMap =
              loadAndGetDataMap(identifier, indexFileStore, blockMetaInfoMap,
                  identifierWrapper.getCarbonTable(),
                  identifierWrapper.isAddTableBlockToUnsafeAndLRUCache(),
                  identifierWrapper.getConfiguration(), indexInfos);
          dataMaps.add(blockletDataMap);
          blockletDataMapIndexWrapper =
              new BlockletDataMapIndexWrapper(identifier.getSegmentId(), dataMaps);
        } else {
          // if the identifier is a merge file then collect the index files and load the datamaps
          List<TableBlockIndexUniqueIdentifier> tableBlockIndexUniqueIdentifiers =
              BlockletDataMapUtil.getIndexFileIdentifiersFromMergeFile(identifier, indexFileStore);
          for (TableBlockIndexUniqueIdentifier blockIndexUniqueIdentifier :
              tableBlockIndexUniqueIdentifiers) {
            List<DataFileFooter> indexInfos = new ArrayList<>();
            Map<String, BlockMetaInfo> blockMetaInfoMap = BlockletDataMapUtil.getBlockMetaInfoMap(
                new TableBlockIndexUniqueIdentifierWrapper(blockIndexUniqueIdentifier,
                    identifierWrapper.getCarbonTable()), indexFileStore, filesRead,
                carbonDataFileBlockMetaInfoMapping, indexInfos);
            if (!blockMetaInfoMap.isEmpty()) {
              BlockDataMap blockletDataMap =
                  loadAndGetDataMap(blockIndexUniqueIdentifier, indexFileStore, blockMetaInfoMap,
                      identifierWrapper.getCarbonTable(),
                      identifierWrapper.isAddTableBlockToUnsafeAndLRUCache(),
                      identifierWrapper.getConfiguration(), indexInfos);
              dataMaps.add(blockletDataMap);
            }
          }
          blockletDataMapIndexWrapper =
              new BlockletDataMapIndexWrapper(identifier.getSegmentId(), dataMaps);
        }
        if (identifierWrapper.isAddTableBlockToUnsafeAndLRUCache()) {
          lruCache.put(identifier.getUniqueTableSegmentIdentifier(), blockletDataMapIndexWrapper,
              blockletDataMapIndexWrapper.getMemorySize());
        }
      } catch (Throwable e) {
        // clear all the memory used by datamaps loaded
        for (DataMap dataMap : dataMaps) {
          dataMap.clear();
        }
        LOGGER.error("memory exception when loading datamap: " + e.getMessage(), e);
        throw new RuntimeException(e);
      }
    }
    return blockletDataMapIndexWrapper;
  }

  @Override public List<BlockletDataMapIndexWrapper> getAll(
      List<TableBlockIndexUniqueIdentifierWrapper> tableSegmentUniqueIdentifiers)
      throws IOException {
    Map<String, Map<String, BlockMetaInfo>> segInfoCache
        = new HashMap<String, Map<String, BlockMetaInfo>>();

    List<BlockletDataMapIndexWrapper> blockletDataMapIndexWrappers =
        new ArrayList<>(tableSegmentUniqueIdentifiers.size());
    List<TableBlockIndexUniqueIdentifierWrapper> missedIdentifiersWrapper = new ArrayList<>();
    BlockletDataMapIndexWrapper blockletDataMapIndexWrapper = null;
    // Get the datamaps for each indexfile from cache.
    try {
      for (TableBlockIndexUniqueIdentifierWrapper
               identifierWrapper : tableSegmentUniqueIdentifiers) {
        BlockletDataMapIndexWrapper dataMapIndexWrapper =
            getIfPresent(identifierWrapper);
        if (dataMapIndexWrapper != null) {
          blockletDataMapIndexWrappers.add(dataMapIndexWrapper);
        } else {
          missedIdentifiersWrapper.add(identifierWrapper);
        }
      }
      if (missedIdentifiersWrapper.size() > 0) {
        for (TableBlockIndexUniqueIdentifierWrapper identifierWrapper : missedIdentifiersWrapper) {
          blockletDataMapIndexWrapper = get(identifierWrapper, segInfoCache);
          blockletDataMapIndexWrappers.add(blockletDataMapIndexWrapper);
        }
      }
    } catch (Throwable e) {
      if (null != blockletDataMapIndexWrapper) {
        List<BlockDataMap> dataMaps = blockletDataMapIndexWrapper.getDataMaps();
        for (DataMap dataMap : dataMaps) {
          dataMap.clear();
        }
      }
      throw new IOException("Problem in loading segment blocks: " + e.getMessage(), e);
    }

    return blockletDataMapIndexWrappers;
  }

  /**
   * returns the SegmentTaskIndexWrapper
   *
   * @param tableSegmentUniqueIdentifierWrapper
   * @return
   */
  @Override public BlockletDataMapIndexWrapper getIfPresent(
      TableBlockIndexUniqueIdentifierWrapper tableSegmentUniqueIdentifierWrapper) {
    return (BlockletDataMapIndexWrapper) lruCache.get(
        tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()
            .getUniqueTableSegmentIdentifier());
  }

  /**
   * method invalidate the segment cache for segment
   *
   * @param tableSegmentUniqueIdentifierWrapper
   */
  @Override public void invalidate(
      TableBlockIndexUniqueIdentifierWrapper tableSegmentUniqueIdentifierWrapper) {
    BlockletDataMapIndexWrapper blockletDataMapIndexWrapper =
        getIfPresent(tableSegmentUniqueIdentifierWrapper);
    if (null != blockletDataMapIndexWrapper) {
      // clear the segmentProperties cache
      List<BlockDataMap> dataMaps = blockletDataMapIndexWrapper.getDataMaps();
      if (null != dataMaps && !dataMaps.isEmpty()) {
        String segmentId =
            tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier().getSegmentId();
        // as segmentId will be same for all the dataMaps and segmentProperties cache is
        // maintained at segment level so it need to be called only once for clearing
        SegmentPropertiesAndSchemaHolder.getInstance()
            .invalidate(segmentId, dataMaps.get(0).getSegmentPropertiesIndex(),
                tableSegmentUniqueIdentifierWrapper.isAddTableBlockToUnsafeAndLRUCache());
      }
    }
    lruCache.remove(tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()
        .getUniqueTableSegmentIdentifier());
  }

  @Override
  public void put(TableBlockIndexUniqueIdentifierWrapper tableBlockIndexUniqueIdentifierWrapper,
      BlockletDataMapIndexWrapper wrapper) throws IOException, MemoryException {
    // As dataMap will use unsafe memory, it is not recommended to overwrite an existing entry
    // as in that case clearing unsafe memory need to be taken card. If at all datamap entry
    // in the cache need to be overwritten then use the invalidate interface
    // and then use the put interface
    if (null == getIfPresent(tableBlockIndexUniqueIdentifierWrapper)) {
      List<BlockDataMap> dataMaps = wrapper.getDataMaps();
      try {
        for (BlockDataMap blockletDataMap : dataMaps) {
          blockletDataMap.convertToUnsafeDMStore();
        }
        // Locking is not required here because in LRU cache map add method is synchronized to add
        // only one entry at a time and if a key already exists it will not overwrite the entry
        lruCache.put(tableBlockIndexUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()
            .getUniqueTableSegmentIdentifier(), wrapper, wrapper.getMemorySize());
      } catch (Throwable e) {
        // clear all the memory acquired by data map in case of any failure
        for (DataMap blockletDataMap : dataMaps) {
          blockletDataMap.clear();
        }
        throw new IOException("Problem in adding datamap to cache.", e);
      }
    }
  }


  /**
   * Below method will be used to load the segment of segments
   * One segment may have multiple task , so  table segment will be loaded
   * based on task id and will return the map of taksId to table segment
   * map
   *
   * @return map of taks id to segment mapping
   * @throws IOException
   */
  private BlockDataMap loadAndGetDataMap(TableBlockIndexUniqueIdentifier identifier,
      SegmentIndexFileStore indexFileStore, Map<String, BlockMetaInfo> blockMetaInfoMap,
      CarbonTable carbonTable, boolean addTableBlockToUnsafe, Configuration configuration,
      List<DataFileFooter> indexInfos)
      throws IOException, MemoryException {
    String uniqueTableSegmentIdentifier =
        identifier.getUniqueTableSegmentIdentifier();
    Object lock = segmentLockMap.get(uniqueTableSegmentIdentifier);
    if (lock == null) {
      lock = addAndGetSegmentLock(uniqueTableSegmentIdentifier);
    }
    BlockDataMap dataMap;
    synchronized (lock) {
      dataMap = (BlockDataMap) BlockletDataMapFactory.createDataMap(carbonTable);
      final BlockletDataMapModel blockletDataMapModel = new BlockletDataMapModel(carbonTable,
          identifier.getIndexFilePath() + CarbonCommonConstants.FILE_SEPARATOR + identifier
              .getIndexFileName(), indexFileStore.getFileData(identifier.getIndexFileName()),
          blockMetaInfoMap, identifier.getSegmentId(), addTableBlockToUnsafe, configuration);
      blockletDataMapModel.setIndexInfos(indexInfos);
      dataMap.init(blockletDataMapModel);
    }
    return dataMap;
  }

  /**
   * Below method will be used to get the segment level lock object
   *
   * @param uniqueIdentifier
   * @return lock object
   */
  private synchronized Object addAndGetSegmentLock(String uniqueIdentifier) {
    // get the segment lock object if it is present then return
    // otherwise add the new lock and return
    Object segmentLoderLockObject = segmentLockMap.get(uniqueIdentifier);
    if (null == segmentLoderLockObject) {
      segmentLoderLockObject = new Object();
      segmentLockMap.put(uniqueIdentifier, segmentLoderLockObject);
    }
    return segmentLoderLockObject;
  }

  /**
   * The method clears the access count of table segments
   *
   * @param tableSegmentUniqueIdentifiersWrapper
   */
  @Override public void clearAccessCount(
      List<TableBlockIndexUniqueIdentifierWrapper> tableSegmentUniqueIdentifiersWrapper) {
    for (TableBlockIndexUniqueIdentifierWrapper
             identifierWrapper : tableSegmentUniqueIdentifiersWrapper) {
      BlockDataMap cacheable = (BlockDataMap) lruCache.get(
          identifierWrapper.getTableBlockIndexUniqueIdentifier().getUniqueTableSegmentIdentifier());
      cacheable.clear();
    }
  }
}

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	package org.apache.carbondata.core.indexstore;
18
19	import java.io.IOException;
20	import java.util.ArrayList;
21	import java.util.HashMap;
22	import java.util.HashSet;
23	import java.util.List;
24	import java.util.Map;
25	import java.util.Set;
26	import java.util.concurrent.ConcurrentHashMap;
27
28	import org.apache.carbondata.common.logging.LogServiceFactory;
29	import org.apache.carbondata.core.cache.Cache;
30	import org.apache.carbondata.core.cache.CarbonLRUCache;
31	import org.apache.carbondata.core.constants.CarbonCommonConstants;
32	import org.apache.carbondata.core.datamap.dev.DataMap;
33	import org.apache.carbondata.core.datastore.block.SegmentPropertiesAndSchemaHolder;
34	import org.apache.carbondata.core.indexstore.blockletindex.BlockDataMap;
35	import org.apache.carbondata.core.indexstore.blockletindex.BlockletDataMapFactory;
36	import org.apache.carbondata.core.indexstore.blockletindex.BlockletDataMapModel;
37	import org.apache.carbondata.core.indexstore.blockletindex.SegmentIndexFileStore;
38	import org.apache.carbondata.core.memory.MemoryException;
39	import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
40	import org.apache.carbondata.core.metadata.schema.table.CarbonTable;
41	import org.apache.carbondata.core.util.BlockletDataMapUtil;
42
43	import org.apache.hadoop.conf.Configuration;
44	import org.apache.log4j.Logger;
45
46	/**
47	* Class to handle loading, unloading,clearing,storing of the table
48	* blocks
49	*/
50	public class BlockletDataMapIndexStore
51	implements Cache<TableBlockIndexUniqueIdentifierWrapper, BlockletDataMapIndexWrapper> {
52	private static final Logger LOGGER =	2✔
53	LogServiceFactory.getLogService(BlockletDataMapIndexStore.class.getName());	2✔
54	/**
55	* CarbonLRU cache
56	*/
57	protected CarbonLRUCache lruCache;
58
59	/**
60	* map of block info to lock object map, while loading the btree this will be filled
61	* and removed after loading the tree for that particular block info, this will be useful
62	* while loading the tree concurrently so only block level lock will be applied another
63	* block can be loaded concurrently
64	*/
65	private Map<String, Object> segmentLockMap;
66
67	/**
68	* constructor to initialize the SegmentTaskIndexStore
69	*
70	* @param lruCache
71	*/
72	public BlockletDataMapIndexStore(CarbonLRUCache lruCache) {	2✔
73	this.lruCache = lruCache;	2✔
74	segmentLockMap = new ConcurrentHashMap<String, Object>();	2✔
75	}	2✔
76
77	@Override
78	public BlockletDataMapIndexWrapper get(TableBlockIndexUniqueIdentifierWrapper identifierWrapper)
79	throws IOException {
80	return get(identifierWrapper, null);	1✔
81	}
82
83	private BlockletDataMapIndexWrapper get(TableBlockIndexUniqueIdentifierWrapper identifierWrapper,
84	Map<String, Map<String, BlockMetaInfo>> segInfoCache) throws IOException {
85	TableBlockIndexUniqueIdentifier identifier =	1✔
86	identifierWrapper.getTableBlockIndexUniqueIdentifier();	1✔
87	String lruCacheKey = identifier.getUniqueTableSegmentIdentifier();	1✔
88	BlockletDataMapIndexWrapper blockletDataMapIndexWrapper =	1✔
89	(BlockletDataMapIndexWrapper) lruCache.get(lruCacheKey);	1✔
90	List<BlockDataMap> dataMaps = new ArrayList<>();	1✔
91	if (blockletDataMapIndexWrapper == null) {	1✔
92	try {
93	SegmentIndexFileStore indexFileStore =	1✔
94	new SegmentIndexFileStore(identifierWrapper.getConfiguration());	1✔
95	Set<String> filesRead = new HashSet<>();	1✔
96	String segmentFilePath = identifier.getIndexFilePath();	1✔
97	if (segInfoCache == null) {	1✔
98	segInfoCache = new HashMap<>();	×
99	}
100	Map<String, BlockMetaInfo> carbonDataFileBlockMetaInfoMapping =	1✔
101	segInfoCache.get(segmentFilePath);	1✔
102	if (carbonDataFileBlockMetaInfoMapping == null) {	1✔
103	carbonDataFileBlockMetaInfoMapping =	1✔
104	BlockletDataMapUtil.createCarbonDataFileBlockMetaInfoMapping(segmentFilePath,	1✔
105	identifierWrapper.getConfiguration());	1✔
106	segInfoCache.put(segmentFilePath, carbonDataFileBlockMetaInfoMapping);	1✔
107	}
108	// if the identifier is not a merge file we can directly load the datamaps
109	if (identifier.getMergeIndexFileName() == null) {	1✔
110	List<DataFileFooter> indexInfos = new ArrayList<>();	1✔
111	Map<String, BlockMetaInfo> blockMetaInfoMap = BlockletDataMapUtil	1✔
112	.getBlockMetaInfoMap(identifierWrapper, indexFileStore, filesRead,	1✔
113	carbonDataFileBlockMetaInfoMapping, indexInfos);
114	BlockDataMap blockletDataMap =	1✔
115	loadAndGetDataMap(identifier, indexFileStore, blockMetaInfoMap,	1✔
116	identifierWrapper.getCarbonTable(),	1✔
117	identifierWrapper.isAddTableBlockToUnsafeAndLRUCache(),	1✔
118	identifierWrapper.getConfiguration(), indexInfos);	1✔
119	dataMaps.add(blockletDataMap);	1✔
120	blockletDataMapIndexWrapper =	1✔
121	new BlockletDataMapIndexWrapper(identifier.getSegmentId(), dataMaps);	1✔
122	} else {	1✔
123	// if the identifier is a merge file then collect the index files and load the datamaps
124	List<TableBlockIndexUniqueIdentifier> tableBlockIndexUniqueIdentifiers =	1✔
125	BlockletDataMapUtil.getIndexFileIdentifiersFromMergeFile(identifier, indexFileStore);	1✔
126	for (TableBlockIndexUniqueIdentifier blockIndexUniqueIdentifier :
127	tableBlockIndexUniqueIdentifiers) {	1✔
128	List<DataFileFooter> indexInfos = new ArrayList<>();	1✔
129	Map<String, BlockMetaInfo> blockMetaInfoMap = BlockletDataMapUtil.getBlockMetaInfoMap(	1✔
130	new TableBlockIndexUniqueIdentifierWrapper(blockIndexUniqueIdentifier,
131	identifierWrapper.getCarbonTable()), indexFileStore, filesRead,	1✔
132	carbonDataFileBlockMetaInfoMapping, indexInfos);
133	if (!blockMetaInfoMap.isEmpty()) {	1✔
134	BlockDataMap blockletDataMap =	1✔
135	loadAndGetDataMap(blockIndexUniqueIdentifier, indexFileStore, blockMetaInfoMap,	1✔
136	identifierWrapper.getCarbonTable(),	1✔
137	identifierWrapper.isAddTableBlockToUnsafeAndLRUCache(),	1✔
138	identifierWrapper.getConfiguration(), indexInfos);	1✔
139	dataMaps.add(blockletDataMap);	1✔
140	}
141	}	1✔
142	blockletDataMapIndexWrapper =	1✔
143	new BlockletDataMapIndexWrapper(identifier.getSegmentId(), dataMaps);	1✔
144	}
145	if (identifierWrapper.isAddTableBlockToUnsafeAndLRUCache()) {	1✔
146	lruCache.put(identifier.getUniqueTableSegmentIdentifier(), blockletDataMapIndexWrapper,	1✔
147	blockletDataMapIndexWrapper.getMemorySize());	1✔
148	}
149	} catch (Throwable e) {	1✔
150	// clear all the memory used by datamaps loaded
151	for (DataMap dataMap : dataMaps) {	1✔
152	dataMap.clear();	×
153	}	×
154	LOGGER.error("memory exception when loading datamap: " + e.getMessage(), e);	1✔
155	throw new RuntimeException(e);	1✔
156	}	1✔
157	}
158	return blockletDataMapIndexWrapper;	1✔
159	}
160
161	@Override public List<BlockletDataMapIndexWrapper> getAll(
162	List<TableBlockIndexUniqueIdentifierWrapper> tableSegmentUniqueIdentifiers)
163	throws IOException {
164	Map<String, Map<String, BlockMetaInfo>> segInfoCache	1✔
165	= new HashMap<String, Map<String, BlockMetaInfo>>();
166
167	List<BlockletDataMapIndexWrapper> blockletDataMapIndexWrappers =	1✔
168	new ArrayList<>(tableSegmentUniqueIdentifiers.size());	1✔
169	List<TableBlockIndexUniqueIdentifierWrapper> missedIdentifiersWrapper = new ArrayList<>();	1✔
170	BlockletDataMapIndexWrapper blockletDataMapIndexWrapper = null;	1✔
171	// Get the datamaps for each indexfile from cache.
172	try {
173	for (TableBlockIndexUniqueIdentifierWrapper
174	identifierWrapper : tableSegmentUniqueIdentifiers) {	1✔
175	BlockletDataMapIndexWrapper dataMapIndexWrapper =	1✔
176	getIfPresent(identifierWrapper);	1✔
177	if (dataMapIndexWrapper != null) {	1✔
178	blockletDataMapIndexWrappers.add(dataMapIndexWrapper);	1✔
179	} else {
180	missedIdentifiersWrapper.add(identifierWrapper);	1✔
181	}
182	}	1✔
183	if (missedIdentifiersWrapper.size() > 0) {	1✔
184	for (TableBlockIndexUniqueIdentifierWrapper identifierWrapper : missedIdentifiersWrapper) {	1✔
185	blockletDataMapIndexWrapper = get(identifierWrapper, segInfoCache);	1✔
186	blockletDataMapIndexWrappers.add(blockletDataMapIndexWrapper);	1✔
187	}	1✔
188	}
189	} catch (Throwable e) {	1✔
190	if (null != blockletDataMapIndexWrapper) {	1✔
191	List<BlockDataMap> dataMaps = blockletDataMapIndexWrapper.getDataMaps();	×
192	for (DataMap dataMap : dataMaps) {	×
193	dataMap.clear();	×
194	}	×
195	}
196	throw new IOException("Problem in loading segment blocks: " + e.getMessage(), e);	1✔
197	}	1✔
198
199	return blockletDataMapIndexWrappers;	1✔
200	}
201
202	/**
203	* returns the SegmentTaskIndexWrapper
204	*
205	* @param tableSegmentUniqueIdentifierWrapper
206	* @return
207	*/
208	@Override public BlockletDataMapIndexWrapper getIfPresent(
209	TableBlockIndexUniqueIdentifierWrapper tableSegmentUniqueIdentifierWrapper) {
210	return (BlockletDataMapIndexWrapper) lruCache.get(	2✔
211	tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()	2✔
212	.getUniqueTableSegmentIdentifier());	2✔
213	}
214
215	/**
216	* method invalidate the segment cache for segment
217	*
218	* @param tableSegmentUniqueIdentifierWrapper
219	*/
220	@Override public void invalidate(
221	TableBlockIndexUniqueIdentifierWrapper tableSegmentUniqueIdentifierWrapper) {
222	BlockletDataMapIndexWrapper blockletDataMapIndexWrapper =	1✔
223	getIfPresent(tableSegmentUniqueIdentifierWrapper);	1✔
224	if (null != blockletDataMapIndexWrapper) {	1✔
225	// clear the segmentProperties cache
226	List<BlockDataMap> dataMaps = blockletDataMapIndexWrapper.getDataMaps();	1✔
227	if (null != dataMaps && !dataMaps.isEmpty()) {	1✔
228	String segmentId =	1✔
229	tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier().getSegmentId();	1✔
230	// as segmentId will be same for all the dataMaps and segmentProperties cache is
231	// maintained at segment level so it need to be called only once for clearing
232	SegmentPropertiesAndSchemaHolder.getInstance()	1✔
233	.invalidate(segmentId, dataMaps.get(0).getSegmentPropertiesIndex(),	1✔
234	tableSegmentUniqueIdentifierWrapper.isAddTableBlockToUnsafeAndLRUCache());	1✔
235	}
236	}
237	lruCache.remove(tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()	1✔
238	.getUniqueTableSegmentIdentifier());	1✔
239	}	1✔
240
241	@Override
242	public void put(TableBlockIndexUniqueIdentifierWrapper tableBlockIndexUniqueIdentifierWrapper,
243	BlockletDataMapIndexWrapper wrapper) throws IOException, MemoryException {
244	// As dataMap will use unsafe memory, it is not recommended to overwrite an existing entry
245	// as in that case clearing unsafe memory need to be taken card. If at all datamap entry
246	// in the cache need to be overwritten then use the invalidate interface
247	// and then use the put interface
248	if (null == getIfPresent(tableBlockIndexUniqueIdentifierWrapper)) {	2✔
249	List<BlockDataMap> dataMaps = wrapper.getDataMaps();	2✔
250	try {
251	for (BlockDataMap blockletDataMap : dataMaps) {	2✔
252	blockletDataMap.convertToUnsafeDMStore();	×
253	}	×
254	// Locking is not required here because in LRU cache map add method is synchronized to add
255	// only one entry at a time and if a key already exists it will not overwrite the entry
256	lruCache.put(tableBlockIndexUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()	2✔
257	.getUniqueTableSegmentIdentifier(), wrapper, wrapper.getMemorySize());	2✔
258	} catch (Throwable e) {	×
259	// clear all the memory acquired by data map in case of any failure
260	for (DataMap blockletDataMap : dataMaps) {	×
261	blockletDataMap.clear();	×
262	}	×
263	throw new IOException("Problem in adding datamap to cache.", e);	×
264	}	2✔
265	}
266	}	2✔
267
268
269	/**
270	* Below method will be used to load the segment of segments
271	* One segment may have multiple task , so table segment will be loaded
272	* based on task id and will return the map of taksId to table segment
273	* map
274	*
275	* @return map of taks id to segment mapping
276	* @throws IOException
277	*/
278	private BlockDataMap loadAndGetDataMap(TableBlockIndexUniqueIdentifier identifier,
279	SegmentIndexFileStore indexFileStore, Map<String, BlockMetaInfo> blockMetaInfoMap,
280	CarbonTable carbonTable, boolean addTableBlockToUnsafe, Configuration configuration,
281	List<DataFileFooter> indexInfos)
282	throws IOException, MemoryException {
283	String uniqueTableSegmentIdentifier =	1✔
284	identifier.getUniqueTableSegmentIdentifier();	1✔
285	Object lock = segmentLockMap.get(uniqueTableSegmentIdentifier);	1✔
286	if (lock == null) {	1✔
287	lock = addAndGetSegmentLock(uniqueTableSegmentIdentifier);	1✔
288	}
289	BlockDataMap dataMap;
290	synchronized (lock) {	1✔
291	dataMap = (BlockDataMap) BlockletDataMapFactory.createDataMap(carbonTable);	1✔
292	final BlockletDataMapModel blockletDataMapModel = new BlockletDataMapModel(carbonTable,	1✔
293	identifier.getIndexFilePath() + CarbonCommonConstants.FILE_SEPARATOR + identifier	1✔
294	.getIndexFileName(), indexFileStore.getFileData(identifier.getIndexFileName()),	1✔
295	blockMetaInfoMap, identifier.getSegmentId(), addTableBlockToUnsafe, configuration);	1✔
296	blockletDataMapModel.setIndexInfos(indexInfos);	1✔
297	dataMap.init(blockletDataMapModel);	1✔
298	}	1✔
299	return dataMap;	1✔
300	}
301
302	/**
303	* Below method will be used to get the segment level lock object
304	*
305	* @param uniqueIdentifier
306	* @return lock object
307	*/
308	private synchronized Object addAndGetSegmentLock(String uniqueIdentifier) {
309	// get the segment lock object if it is present then return
310	// otherwise add the new lock and return
311	Object segmentLoderLockObject = segmentLockMap.get(uniqueIdentifier);	1✔
312	if (null == segmentLoderLockObject) {	1✔
313	segmentLoderLockObject = new Object();	1✔
314	segmentLockMap.put(uniqueIdentifier, segmentLoderLockObject);	1✔
315	}
316	return segmentLoderLockObject;	1✔
317	}
318
319	/**
320	* The method clears the access count of table segments
321	*
322	* @param tableSegmentUniqueIdentifiersWrapper
323	*/
324	@Override public void clearAccessCount(
325	List<TableBlockIndexUniqueIdentifierWrapper> tableSegmentUniqueIdentifiersWrapper) {
326	for (TableBlockIndexUniqueIdentifierWrapper
327	identifierWrapper : tableSegmentUniqueIdentifiersWrapper) {	×
328	BlockDataMap cacheable = (BlockDataMap) lruCache.get(	×
329	identifierWrapper.getTableBlockIndexUniqueIdentifier().getUniqueTableSegmentIdentifier());	×
330	cacheable.clear();	×
331	}	×
332	}	×
333	}

apache / carbondata / 11933

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