11485

Build # 11485

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/a6879d77c808a78d35fecda3567b8ae4cea5f826">a6879d77c<a href="https://github.com/apache/carbondata/commit/a6879d77c808a78d35fecda3567b8ae4cea5f826">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/5e42386176cd32221fbf1a43cd70197176a9d793">5e4238617</a>">5e4238617</a><a href="https://github.com/apache/carbondata/commit/a6879d77c808a78d35fecda3567b8ae4cea5f826"> into 1241feec9">1241feec9</a>

Run Details

56 of 56 new or added lines in 5 files covered. (100.0%)

63805 of 80433 relevant lines covered (79.33%)

1.05 hits per line

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

86.21

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

apache / carbondata / 11485

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