8912

Build # 8912

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/e696e6789356d1851d19fc45ffca36e336d10de9">e696e6789<a href="https://github.com/apache/carbondata/commit/e696e6789356d1851d19fc45ffca36e336d10de9">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/ffab344f319eb985c9c08759f3ca226adb61e348">ffab344f3</a>">ffab344f3</a><a href="https://github.com/apache/carbondata/commit/e696e6789356d1851d19fc45ffca36e336d10de9"> into 9ae91cc5a">9ae91cc5a</a>

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

60553 of 75073 relevant lines covered (80.66%)

1.06 hits per line

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

86.39

/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.LogService;
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;

/**
 * Class to handle loading, unloading,clearing,storing of the table
 * blocks
 */
public class BlockletDataMapIndexStore
    implements Cache<TableBlockIndexUniqueIdentifierWrapper, BlockletDataMapIndexWrapper> {
  private static final LogService 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,
                  identifierWrapper.getConfiguration());
        } 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,
                  identifierWrapper.getConfiguration());
        }
        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());
        throw new RuntimeException(e.getMessage(), 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);
    }

    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.LogService;
29	import org.apache.carbondata.common.logging.LogServiceFactory;
30	import org.apache.carbondata.core.cache.Cache;
31	import org.apache.carbondata.core.cache.CarbonLRUCache;
32	import org.apache.carbondata.core.constants.CarbonCommonConstants;
33	import org.apache.carbondata.core.datamap.dev.DataMap;
34	import org.apache.carbondata.core.datastore.block.SegmentPropertiesAndSchemaHolder;
35	import org.apache.carbondata.core.indexstore.blockletindex.BlockDataMap;
36	import org.apache.carbondata.core.indexstore.blockletindex.BlockletDataMapFactory;
37	import org.apache.carbondata.core.indexstore.blockletindex.BlockletDataMapModel;
38	import org.apache.carbondata.core.indexstore.blockletindex.SegmentIndexFileStore;
39	import org.apache.carbondata.core.memory.MemoryException;
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
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 LogService 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	identifierWrapper.getConfiguration());	1✔
121	} else {	1✔
122	// if the identifier is a merge file then collect the index files and load the datamaps
123	List<TableBlockIndexUniqueIdentifier> tableBlockIndexUniqueIdentifiers =	1✔
124	BlockletDataMapUtil.getIndexFileIdentifiersFromMergeFile(identifier, indexFileStore);	1✔
125	for (TableBlockIndexUniqueIdentifier blockIndexUniqueIdentifier :
126	tableBlockIndexUniqueIdentifiers) {	1✔
127	Map<String, BlockMetaInfo> blockMetaInfoMap = BlockletDataMapUtil.getBlockMetaInfoMap(	1✔
128	new TableBlockIndexUniqueIdentifierWrapper(blockIndexUniqueIdentifier,
129	identifierWrapper.getCarbonTable()), indexFileStore, filesRead,	1✔
130	carbonDataFileBlockMetaInfoMapping);
131	if (!blockMetaInfoMap.isEmpty()) {	1✔
132	BlockDataMap blockletDataMap =	1✔
133	loadAndGetDataMap(blockIndexUniqueIdentifier, indexFileStore, blockMetaInfoMap,	1✔
134	identifierWrapper.getCarbonTable(),	1✔
135	identifierWrapper.isAddTableBlockToUnsafeAndLRUCache(),	1✔
136	identifierWrapper.getConfiguration());	1✔
137	dataMaps.add(blockletDataMap);	1✔
138	}
139	}	1✔
140	blockletDataMapIndexWrapper =	1✔
141	new BlockletDataMapIndexWrapper(identifier.getSegmentId(), dataMaps,	1✔
142	identifierWrapper.getConfiguration());	1✔
143	}
144	if (identifierWrapper.isAddTableBlockToUnsafeAndLRUCache()) {	1✔
145	lruCache.put(identifier.getUniqueTableSegmentIdentifier(), blockletDataMapIndexWrapper,	1✔
146	blockletDataMapIndexWrapper.getMemorySize());	1✔
147	}
148	} catch (Throwable e) {	1✔
149	// clear all the memory used by datamaps loaded
150	for (DataMap dataMap : dataMaps) {	1✔
151	dataMap.clear();	×
152	}	×
153	LOGGER.error("memory exception when loading datamap: " + e.getMessage());	1✔
154	throw new RuntimeException(e.getMessage(), e);	1✔
155	}	1✔
156	}
157	return blockletDataMapIndexWrapper;	1✔
158	}
159
160	@Override public List<BlockletDataMapIndexWrapper> getAll(
161	List<TableBlockIndexUniqueIdentifierWrapper> tableSegmentUniqueIdentifiers)
162	throws IOException {
163	Map<String, Map<String, BlockMetaInfo>> segInfoCache	1✔
164	= new HashMap<String, Map<String, BlockMetaInfo>>();
165
166	List<BlockletDataMapIndexWrapper> blockletDataMapIndexWrappers =	1✔
167	new ArrayList<>(tableSegmentUniqueIdentifiers.size());	1✔
168	List<TableBlockIndexUniqueIdentifierWrapper> missedIdentifiersWrapper = new ArrayList<>();	1✔
169	BlockletDataMapIndexWrapper blockletDataMapIndexWrapper = null;	1✔
170	// Get the datamaps for each indexfile from cache.
171	try {
172	for (TableBlockIndexUniqueIdentifierWrapper
173	identifierWrapper : tableSegmentUniqueIdentifiers) {	1✔
174	BlockletDataMapIndexWrapper dataMapIndexWrapper =	1✔
175	getIfPresent(identifierWrapper);	1✔
176	if (dataMapIndexWrapper != null) {	1✔
177	blockletDataMapIndexWrappers.add(dataMapIndexWrapper);	1✔
178	} else {
179	missedIdentifiersWrapper.add(identifierWrapper);	1✔
180	}
181	}	1✔
182	if (missedIdentifiersWrapper.size() > 0) {	1✔
183	for (TableBlockIndexUniqueIdentifierWrapper identifierWrapper : missedIdentifiersWrapper) {	1✔
184	blockletDataMapIndexWrapper = get(identifierWrapper, segInfoCache);	1✔
185	blockletDataMapIndexWrappers.add(blockletDataMapIndexWrapper);	1✔
186	}	1✔
187	}
188	} catch (Throwable e) {	1✔
189	if (null != blockletDataMapIndexWrapper) {	1✔
190	List<BlockDataMap> dataMaps = blockletDataMapIndexWrapper.getDataMaps();	×
191	for (DataMap dataMap : dataMaps) {	×
192	dataMap.clear();	×
193	}	×
194	}
195	throw new IOException("Problem in loading segment blocks.", e);	1✔
196	}	1✔
197
198	return blockletDataMapIndexWrappers;	1✔
199	}
200
201	/**
202	* returns the SegmentTaskIndexWrapper
203	*
204	* @param tableSegmentUniqueIdentifierWrapper
205	* @return
206	*/
207	@Override public BlockletDataMapIndexWrapper getIfPresent(
208	TableBlockIndexUniqueIdentifierWrapper tableSegmentUniqueIdentifierWrapper) {
209	return (BlockletDataMapIndexWrapper) lruCache.get(	2✔
210	tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()	2✔
211	.getUniqueTableSegmentIdentifier());	2✔
212	}
213
214	/**
215	* method invalidate the segment cache for segment
216	*
217	* @param tableSegmentUniqueIdentifierWrapper
218	*/
219	@Override public void invalidate(
220	TableBlockIndexUniqueIdentifierWrapper tableSegmentUniqueIdentifierWrapper) {
221	BlockletDataMapIndexWrapper blockletDataMapIndexWrapper =	1✔
222	getIfPresent(tableSegmentUniqueIdentifierWrapper);	1✔
223	if (null != blockletDataMapIndexWrapper) {	1✔
224	// clear the segmentProperties cache
225	List<BlockDataMap> dataMaps = blockletDataMapIndexWrapper.getDataMaps();	1✔
226	if (null != dataMaps && !dataMaps.isEmpty()) {	1✔
227	String segmentId =	1✔
228	tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier().getSegmentId();	1✔
229	// as segmentId will be same for all the dataMaps and segmentProperties cache is
230	// maintained at segment level so it need to be called only once for clearing
231	SegmentPropertiesAndSchemaHolder.getInstance()	1✔
232	.invalidate(segmentId, dataMaps.get(0).getSegmentPropertiesIndex(),	1✔
233	tableSegmentUniqueIdentifierWrapper.isAddTableBlockToUnsafeAndLRUCache());	1✔
234	}
235	}
236	lruCache.remove(tableSegmentUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()	1✔
237	.getUniqueTableSegmentIdentifier());	1✔
238	}	1✔
239
240	@Override
241	public void put(TableBlockIndexUniqueIdentifierWrapper tableBlockIndexUniqueIdentifierWrapper,
242	BlockletDataMapIndexWrapper wrapper) throws IOException, MemoryException {
243	// As dataMap will use unsafe memory, it is not recommended to overwrite an existing entry
244	// as in that case clearing unsafe memory need to be taken card. If at all datamap entry
245	// in the cache need to be overwritten then use the invalidate interface
246	// and then use the put interface
247	if (null == getIfPresent(tableBlockIndexUniqueIdentifierWrapper)) {	2✔
248	List<BlockDataMap> dataMaps = wrapper.getDataMaps();	2✔
249	try {
250	for (BlockDataMap blockletDataMap : dataMaps) {	2✔
251	blockletDataMap.convertToUnsafeDMStore();	×
252	}	×
253	// Locking is not required here because in LRU cache map add method is synchronized to add
254	// only one entry at a time and if a key already exists it will not overwrite the entry
255	lruCache.put(tableBlockIndexUniqueIdentifierWrapper.getTableBlockIndexUniqueIdentifier()	2✔
256	.getUniqueTableSegmentIdentifier(), wrapper, wrapper.getMemorySize());	2✔
257	} catch (Throwable e) {	×
258	// clear all the memory acquired by data map in case of any failure
259	for (DataMap blockletDataMap : dataMaps) {	×
260	blockletDataMap.clear();	×
261	}	×
262	throw new IOException("Problem in adding datamap to cache.", e);	×
263	}	2✔
264	}
265	}	2✔
266
267
268	/**
269	* Below method will be used to load the segment of segments
270	* One segment may have multiple task , so table segment will be loaded
271	* based on task id and will return the map of taksId to table segment
272	* map
273	*
274	* @return map of taks id to segment mapping
275	* @throws IOException
276	*/
277	private BlockDataMap loadAndGetDataMap(TableBlockIndexUniqueIdentifier identifier,
278	SegmentIndexFileStore indexFileStore, Map<String, BlockMetaInfo> blockMetaInfoMap,
279	CarbonTable carbonTable, boolean addTableBlockToUnsafe, Configuration configuration)
280	throws IOException, MemoryException {
281	String uniqueTableSegmentIdentifier =	1✔
282	identifier.getUniqueTableSegmentIdentifier();	1✔
283	Object lock = segmentLockMap.get(uniqueTableSegmentIdentifier);	1✔
284	if (lock == null) {	1✔
285	lock = addAndGetSegmentLock(uniqueTableSegmentIdentifier);	1✔
286	}
287	BlockDataMap dataMap;
288	synchronized (lock) {	1✔
289	dataMap = (BlockDataMap) BlockletDataMapFactory.createDataMap(carbonTable);	1✔
290	dataMap.init(new BlockletDataMapModel(carbonTable,	1✔
291	identifier.getIndexFilePath() + CarbonCommonConstants.FILE_SEPARATOR + identifier	1✔
292	.getIndexFileName(), indexFileStore.getFileData(identifier.getIndexFileName()),	1✔
293	blockMetaInfoMap, identifier.getSegmentId(), addTableBlockToUnsafe, configuration));	1✔
294	}	1✔
295	return dataMap;	1✔
296	}
297
298	/**
299	* Below method will be used to get the segment level lock object
300	*
301	* @param uniqueIdentifier
302	* @return lock object
303	*/
304	private synchronized Object addAndGetSegmentLock(String uniqueIdentifier) {
305	// get the segment lock object if it is present then return
306	// otherwise add the new lock and return
307	Object segmentLoderLockObject = segmentLockMap.get(uniqueIdentifier);	1✔
308	if (null == segmentLoderLockObject) {	1✔
309	segmentLoderLockObject = new Object();	1✔
310	segmentLockMap.put(uniqueIdentifier, segmentLoderLockObject);	1✔
311	}
312	return segmentLoderLockObject;	1✔
313	}
314
315	/**
316	* The method clears the access count of table segments
317	*
318	* @param tableSegmentUniqueIdentifiersWrapper
319	*/
320	@Override public void clearAccessCount(
321	List<TableBlockIndexUniqueIdentifierWrapper> tableSegmentUniqueIdentifiersWrapper) {
322	for (TableBlockIndexUniqueIdentifierWrapper
323	identifierWrapper : tableSegmentUniqueIdentifiersWrapper) {	×
324	BlockDataMap cacheable = (BlockDataMap) lruCache.get(	×
325	identifierWrapper.getTableBlockIndexUniqueIdentifier().getUniqueTableSegmentIdentifier());	×
326	cacheable.clear();	×
327	}	×
328	}	×
329	}

apache / carbondata / 8912

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