2887

Build # 2887

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/b3690a428b6f696b78753282e834ae45311449fd">b3690a428<a href="https://github.com/apache/carbondata/commit/b3690a428b6f696b78753282e834ae45311449fd">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/8df8f962d8ba22ac79610526c4d58f2281d55342">8df8f962d</a>">8df8f962d</a><a href="https://github.com/apache/carbondata/commit/b3690a428b6f696b78753282e834ae45311449fd"> into 718be3729">718be3729</a>

Run Details

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

62681 of 79175 relevant lines covered (79.17%)

1.05 hits per line

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

95.54

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

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.util.CarbonProperties;

import org.apache.log4j.Logger;

/**
 * class which manages the lru cache
 */
public final class CarbonLRUCache {
  /**
   * constant for converting MB into bytes
   */
  private static final int BYTE_CONVERSION_CONSTANT = 1024 * 1024;
  /**
   * Attribute for Carbon LOGGER
   */
  private static final Logger LOGGER =
      LogServiceFactory.getLogService(CarbonLRUCache.class.getName());
  /**
   * Map that will contain key as table unique name and value as cache Holder
   * object
   */
  private Map<String, Cacheable> lruCacheMap;
  /**
   * lruCacheSize
   */
  private long lruCacheMemorySize;
  /**
   * totalSize size of the cache
   */
  private long currentSize;

  /**
   * @param propertyName        property name to take the size configured
   * @param defaultPropertyName default property in case size is not configured
   */
  public CarbonLRUCache(String propertyName, String defaultPropertyName) {
    try {
      lruCacheMemorySize = Integer
          .parseInt(CarbonProperties.getInstance().getProperty(propertyName, defaultPropertyName));
    } catch (NumberFormatException e) {
      lruCacheMemorySize = Integer.parseInt(defaultPropertyName);
    }

    // if lru cache is bigger than jvm max heap then set part size of max heap (60% default)
    if (isBeyondMaxMemory()) {
      double changeSize = getPartOfXmx();
      LOGGER.warn("Configured LRU size " + lruCacheMemorySize +
              "MB exceeds the max size of JVM heap. Carbon will fallback to use " +
              changeSize + " MB instead");
      lruCacheMemorySize = (long)changeSize;
    }

    initCache();
    if (lruCacheMemorySize > 0) {
      LOGGER.info("Configured LRU cache size is " + lruCacheMemorySize + " MB");
      // convert in bytes
      lruCacheMemorySize = lruCacheMemorySize * BYTE_CONVERSION_CONSTANT;
    } else {
      LOGGER.info("LRU cache size not configured. Therefore default behavior will be "
              + "considered and no LRU based eviction of columns will be done");
    }
  }

  /**
   * initialize lru cache
   */
  private void initCache() {
    lruCacheMap =
        new LinkedHashMap<String, Cacheable>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE, 1.0f,
            true);
  }

  /**
   * This method will give the list of all the keys that can be deleted from
   * the level LRU cache
   */
  private List<String> getKeysToBeRemoved(long size) {
    List<String> toBeDeletedKeys =
        new ArrayList<String>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
    long removedSize = 0;
    for (Entry<String, Cacheable> entry : lruCacheMap.entrySet()) {
      String key = entry.getKey();
      Cacheable cacheInfo = entry.getValue();
      long memorySize = cacheInfo.getMemorySize();
      if (canBeRemoved(cacheInfo)) {
        removedSize = removedSize + memorySize;
        toBeDeletedKeys.add(key);
        // check if after removing the current file size, required
        // size when added to current size is sufficient to load a
        // level or not
        if (lruCacheMemorySize >= (currentSize - memorySize + size)) {
          toBeDeletedKeys.clear();
          toBeDeletedKeys.add(key);
          removedSize = memorySize;
          break;
        }
        // check if after removing the added size/removed size,
        // required size when added to current size is sufficient to
        // load a level or not
        else if (lruCacheMemorySize >= (currentSize - removedSize + size)) {
          break;
        }
      }
    }
    // this case will come when iteration is complete over the keys but
    // still size is not sufficient for level file to be loaded, then we
    // will not delete any of the keys
    if ((currentSize - removedSize + size) > lruCacheMemorySize) {
      toBeDeletedKeys.clear();
    }
    return toBeDeletedKeys;
  }

  /**
   * @param cacheInfo
   * @return
   */
  private boolean canBeRemoved(Cacheable cacheInfo) {
    if (cacheInfo.getAccessCount() > 0) {
      return false;
    }
    return true;
  }

  /**
   * @param key
   */
  public void remove(String key) {
    synchronized (lruCacheMap) {
      removeKey(key);
    }
  }

  /**
   * This method will remove the key from lru cache
   *
   * @param key
   */
  private void removeKey(String key) {
    Cacheable cacheable = lruCacheMap.get(key);
    if (null != cacheable) {
      long memorySize = cacheable.getMemorySize();
      cacheable.invalidate();
      lruCacheMap.remove(key);
      currentSize = currentSize - memorySize;
      LOGGER.info("Removed entry from InMemory lru cache :: " + key);
    }
  }

  /**
   * This method will check if required size is available in the memory and then add
   * the given cacheable to object to lru cache
   *
   * @param columnIdentifier
   * @param cacheInfo
   */
  public boolean put(String columnIdentifier, Cacheable cacheInfo, long requiredSize) {
    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug("Required size for entry " + columnIdentifier + " :: " + requiredSize
          + " Current cache size :: " + currentSize);
    }
    boolean columnKeyAddedSuccessfully = false;
    if (isLRUCacheSizeConfigured()) {
      synchronized (lruCacheMap) {
        if (freeMemorySizeForAddingCache(requiredSize)) {
          currentSize = currentSize + requiredSize;
          addEntryToLRUCacheMap(columnIdentifier, cacheInfo);
          columnKeyAddedSuccessfully = true;
        } else {
          LOGGER.error(
              "Size not available. Entry cannot be added to lru cache :: " + columnIdentifier
                  + " .Required Size = " + requiredSize + " Size available " + (lruCacheMemorySize
                  - currentSize));
        }
      }
    } else {
      synchronized (lruCacheMap) {
        addEntryToLRUCacheMap(columnIdentifier, cacheInfo);
      }
      columnKeyAddedSuccessfully = true;
    }
    return columnKeyAddedSuccessfully;
  }

  /**
   * This method will check if required size is available in the memory
   * @param columnIdentifier
   * @param requiredSize
   * @return
   */
  public boolean tryPut(String columnIdentifier, long requiredSize) {
    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug("checking Required size for entry " + columnIdentifier + " :: " + requiredSize
          + " Current cache size :: " + currentSize);
    }
    boolean columnKeyCanBeAdded = false;
    if (isLRUCacheSizeConfigured()) {
      synchronized (lruCacheMap) {
        if (freeMemorySizeForAddingCache(requiredSize)) {
          columnKeyCanBeAdded = true;
        } else {
          LOGGER.error(
              "Size check failed.Size not available. Entry cannot be added to lru cache :: "
                  + columnIdentifier + " .Required Size = " + requiredSize + " Size available " + (
                  lruCacheMemorySize - currentSize));
        }
      }
    } else {
      columnKeyCanBeAdded = true;
    }
    return columnKeyCanBeAdded;
  }

  /**
   * The method will add the cache entry to LRU cache map
   *
   * @param columnIdentifier
   * @param cacheInfo
   */
  private void addEntryToLRUCacheMap(String columnIdentifier, Cacheable cacheInfo) {
    if (null == lruCacheMap.get(columnIdentifier)) {
      lruCacheMap.put(columnIdentifier, cacheInfo);
    }
    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug("Added entry to InMemory lru cache :: " + columnIdentifier);
    }
  }

  /**
   * this will check whether the LRU cache size is configured
   *
   * @return <Boolean> value
   */
  private boolean isLRUCacheSizeConfigured() {
    return lruCacheMemorySize > 0;
  }

  /**
   * This method will check a required column can be loaded into memory or not. If required
   * this method will call for eviction of existing data from memory
   *
   * @param requiredSize
   * @return
   */
  private boolean freeMemorySizeForAddingCache(long requiredSize) {
    boolean memoryAvailable = false;
    if (isSizeAvailableToLoadColumnDictionary(requiredSize)) {
      memoryAvailable = true;
    } else {
      // get the keys that can be removed from memory
      List<String> keysToBeRemoved = getKeysToBeRemoved(requiredSize);
      for (String cacheKey : keysToBeRemoved) {
        removeKey(cacheKey);
      }
      // after removing the keys check again if required size is available
      if (isSizeAvailableToLoadColumnDictionary(requiredSize)) {
        memoryAvailable = true;
      }
    }
    return memoryAvailable;
  }

  /**
   * This method will check if size is available to laod dictionary into memory
   *
   * @param requiredSize
   * @return
   */
  private boolean isSizeAvailableToLoadColumnDictionary(long requiredSize) {
    return lruCacheMemorySize >= (currentSize + requiredSize);
  }

  /**
   * @param key
   * @return
   */
  public Cacheable get(String key) {
    synchronized (lruCacheMap) {
      return lruCacheMap.get(key);
    }
  }

  /**
   * This method will empty the level cache
   */
  public void clear() {
    synchronized (lruCacheMap) {
      lruCacheMap.clear();
    }
  }

  public Map<String, Cacheable> getCacheMap() {
    return lruCacheMap;
  }

  /**
   * Check if LRU cache setting is bigger than max memory of jvm.
   * if LRU cache is bigger than max memory of jvm when query for a big segments table,
   * may cause JDBC server crash.
   * @return true LRU cache is bigger than max memory of jvm, false otherwise
   */
  private boolean isBeyondMaxMemory() {
    long mSize = Runtime.getRuntime().maxMemory();
    long lruSize = lruCacheMemorySize * BYTE_CONVERSION_CONSTANT;
    return lruSize >= mSize;
  }

  /**
   * when LRU cache is bigger than max heap of jvm.
   * set to part of  max heap size, use CARBON_LRU_CACHE_PERCENT_OVER_MAX_SIZE default 60%.
   * @return the LRU cache size
   */
  private double getPartOfXmx() {
    long mSizeMB = Runtime.getRuntime().maxMemory() / BYTE_CONVERSION_CONSTANT;
    return mSizeMB * CarbonCommonConstants.CARBON_LRU_CACHE_PERCENT_OVER_MAX_SIZE;
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.carbondata.core.cache;
19
20	import java.util.ArrayList;
21	import java.util.LinkedHashMap;
22	import java.util.List;
23	import java.util.Map;
24	import java.util.Map.Entry;
25
26	import org.apache.carbondata.common.logging.LogServiceFactory;
27	import org.apache.carbondata.core.constants.CarbonCommonConstants;
28	import org.apache.carbondata.core.util.CarbonProperties;
29
30	import org.apache.log4j.Logger;
31
32	/**
33	* class which manages the lru cache
34	*/
35	public final class CarbonLRUCache {
36	/**
37	* constant for converting MB into bytes
38	*/
39	private static final int BYTE_CONVERSION_CONSTANT = 1024 * 1024;
40	/**
41	* Attribute for Carbon LOGGER
42	*/
43	private static final Logger LOGGER =	2✔
44	LogServiceFactory.getLogService(CarbonLRUCache.class.getName());	2✔
45	/**
46	* Map that will contain key as table unique name and value as cache Holder
47	* object
48	*/
49	private Map<String, Cacheable> lruCacheMap;
50	/**
51	* lruCacheSize
52	*/
53	private long lruCacheMemorySize;
54	/**
55	* totalSize size of the cache
56	*/
57	private long currentSize;
58
59	/**
60	* @param propertyName property name to take the size configured
61	* @param defaultPropertyName default property in case size is not configured
62	*/
63	public CarbonLRUCache(String propertyName, String defaultPropertyName) {	2✔
64	try {
65	lruCacheMemorySize = Integer	2✔
66	.parseInt(CarbonProperties.getInstance().getProperty(propertyName, defaultPropertyName));	2✔
67	} catch (NumberFormatException e) {	×
68	lruCacheMemorySize = Integer.parseInt(defaultPropertyName);	×
69	}	2✔
70
71	// if lru cache is bigger than jvm max heap then set part size of max heap (60% default)
72	if (isBeyondMaxMemory()) {	2✔
73	double changeSize = getPartOfXmx();	2✔
74	LOGGER.warn("Configured LRU size " + lruCacheMemorySize +	2✔
75	"MB exceeds the max size of JVM heap. Carbon will fallback to use " +
76	changeSize + " MB instead");
77	lruCacheMemorySize = (long)changeSize;	2✔
78	}
79
80	initCache();	2✔
81	if (lruCacheMemorySize > 0) {	2✔
82	LOGGER.info("Configured LRU cache size is " + lruCacheMemorySize + " MB");	2✔
83	// convert in bytes
84	lruCacheMemorySize = lruCacheMemorySize * BYTE_CONVERSION_CONSTANT;	2✔
85	} else {
86	LOGGER.info("LRU cache size not configured. Therefore default behavior will be "	1✔
87	+ "considered and no LRU based eviction of columns will be done");
88	}
89	}	2✔
90
91	/**
92	* initialize lru cache
93	*/
94	private void initCache() {
95	lruCacheMap =	2✔
96	new LinkedHashMap<String, Cacheable>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE, 1.0f,
97	true);
98	}	2✔
99
100	/**
101	* This method will give the list of all the keys that can be deleted from
102	* the level LRU cache
103	*/
104	private List<String> getKeysToBeRemoved(long size) {
105	List<String> toBeDeletedKeys =	2✔
106	new ArrayList<String>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
107	long removedSize = 0;	2✔
108	for (Entry<String, Cacheable> entry : lruCacheMap.entrySet()) {	2✔
109	String key = entry.getKey();	2✔
110	Cacheable cacheInfo = entry.getValue();	2✔
111	long memorySize = cacheInfo.getMemorySize();	2✔
112	if (canBeRemoved(cacheInfo)) {	2✔
113	removedSize = removedSize + memorySize;	2✔
114	toBeDeletedKeys.add(key);	2✔
115	// check if after removing the current file size, required
116	// size when added to current size is sufficient to load a
117	// level or not
118	if (lruCacheMemorySize >= (currentSize - memorySize + size)) {	2✔
119	toBeDeletedKeys.clear();	2✔
120	toBeDeletedKeys.add(key);	2✔
121	removedSize = memorySize;	2✔
122	break;	2✔
123	}
124	// check if after removing the added size/removed size,
125	// required size when added to current size is sufficient to
126	// load a level or not
127	else if (lruCacheMemorySize >= (currentSize - removedSize + size)) {	2✔
128	break;	×
129	}
130	}
131	}	2✔
132	// this case will come when iteration is complete over the keys but
133	// still size is not sufficient for level file to be loaded, then we
134	// will not delete any of the keys
135	if ((currentSize - removedSize + size) > lruCacheMemorySize) {	2✔
136	toBeDeletedKeys.clear();	2✔
137	}
138	return toBeDeletedKeys;	2✔
139	}
140
141	/**
142	* @param cacheInfo
143	* @return
144	*/
145	private boolean canBeRemoved(Cacheable cacheInfo) {
146	if (cacheInfo.getAccessCount() > 0) {	2✔
147	return false;	×
148	}
149	return true;	2✔
150	}
151
152	/**
153	* @param key
154	*/
155	public void remove(String key) {
156	synchronized (lruCacheMap) {	2✔
157	removeKey(key);	2✔
158	}	2✔
159	}	2✔
160
161	/**
162	* This method will remove the key from lru cache
163	*
164	* @param key
165	*/
166	private void removeKey(String key) {
167	Cacheable cacheable = lruCacheMap.get(key);	2✔
168	if (null != cacheable) {	2✔
169	long memorySize = cacheable.getMemorySize();	2✔
170	cacheable.invalidate();	2✔
171	lruCacheMap.remove(key);	2✔
172	currentSize = currentSize - memorySize;	2✔
173	LOGGER.info("Removed entry from InMemory lru cache :: " + key);	2✔
174	}
175	}	2✔
176
177	/**
178	* This method will check if required size is available in the memory and then add
179	* the given cacheable to object to lru cache
180	*
181	* @param columnIdentifier
182	* @param cacheInfo
183	*/
184	public boolean put(String columnIdentifier, Cacheable cacheInfo, long requiredSize) {
185	if (LOGGER.isDebugEnabled()) {	2✔
186	LOGGER.debug("Required size for entry " + columnIdentifier + " :: " + requiredSize	2✔
187	+ " Current cache size :: " + currentSize);
188	}
189	boolean columnKeyAddedSuccessfully = false;	2✔
190	if (isLRUCacheSizeConfigured()) {	2✔
191	synchronized (lruCacheMap) {	2✔
192	if (freeMemorySizeForAddingCache(requiredSize)) {	2✔
193	currentSize = currentSize + requiredSize;	2✔
194	addEntryToLRUCacheMap(columnIdentifier, cacheInfo);	2✔
195	columnKeyAddedSuccessfully = true;	2✔
196	} else {
197	LOGGER.error(	2✔
198	"Size not available. Entry cannot be added to lru cache :: " + columnIdentifier
199	+ " .Required Size = " + requiredSize + " Size available " + (lruCacheMemorySize
200	- currentSize));
201	}
202	}	2✔
203	} else {
204	synchronized (lruCacheMap) {	1✔
205	addEntryToLRUCacheMap(columnIdentifier, cacheInfo);	1✔
206	}	1✔
207	columnKeyAddedSuccessfully = true;	1✔
208	}
209	return columnKeyAddedSuccessfully;	2✔
210	}
211
212	/**
213	* This method will check if required size is available in the memory
214	* @param columnIdentifier
215	* @param requiredSize
216	* @return
217	*/
218	public boolean tryPut(String columnIdentifier, long requiredSize) {
219	if (LOGGER.isDebugEnabled()) {	2✔
220	LOGGER.debug("checking Required size for entry " + columnIdentifier + " :: " + requiredSize	2✔
221	+ " Current cache size :: " + currentSize);
222	}
223	boolean columnKeyCanBeAdded = false;	2✔
224	if (isLRUCacheSizeConfigured()) {	2✔
225	synchronized (lruCacheMap) {	2✔
226	if (freeMemorySizeForAddingCache(requiredSize)) {	2✔
227	columnKeyCanBeAdded = true;	2✔
228	} else {
229	LOGGER.error(	2✔
230	"Size check failed.Size not available. Entry cannot be added to lru cache :: "
231	+ columnIdentifier + " .Required Size = " + requiredSize + " Size available " + (
232	lruCacheMemorySize - currentSize));
233	}
234	}	2✔
235	} else {
236	columnKeyCanBeAdded = true;	1✔
237	}
238	return columnKeyCanBeAdded;	2✔
239	}
240
241	/**
242	* The method will add the cache entry to LRU cache map
243	*
244	* @param columnIdentifier
245	* @param cacheInfo
246	*/
247	private void addEntryToLRUCacheMap(String columnIdentifier, Cacheable cacheInfo) {
248	if (null == lruCacheMap.get(columnIdentifier)) {	2✔
249	lruCacheMap.put(columnIdentifier, cacheInfo);	2✔
250	}
251	if (LOGGER.isDebugEnabled()) {	2✔
252	LOGGER.debug("Added entry to InMemory lru cache :: " + columnIdentifier);	2✔
253	}
254	}	2✔
255
256	/**
257	* this will check whether the LRU cache size is configured
258	*
259	* @return <Boolean> value
260	*/
261	private boolean isLRUCacheSizeConfigured() {
262	return lruCacheMemorySize > 0;	2✔
263	}
264
265	/**
266	* This method will check a required column can be loaded into memory or not. If required
267	* this method will call for eviction of existing data from memory
268	*
269	* @param requiredSize
270	* @return
271	*/
272	private boolean freeMemorySizeForAddingCache(long requiredSize) {
273	boolean memoryAvailable = false;	2✔
274	if (isSizeAvailableToLoadColumnDictionary(requiredSize)) {	2✔
275	memoryAvailable = true;	2✔
276	} else {
277	// get the keys that can be removed from memory
278	List<String> keysToBeRemoved = getKeysToBeRemoved(requiredSize);	2✔
279	for (String cacheKey : keysToBeRemoved) {	2✔
280	removeKey(cacheKey);	2✔
281	}	2✔
282	// after removing the keys check again if required size is available
283	if (isSizeAvailableToLoadColumnDictionary(requiredSize)) {	2✔
284	memoryAvailable = true;	2✔
285	}
286	}
287	return memoryAvailable;	2✔
288	}
289
290	/**
291	* This method will check if size is available to laod dictionary into memory
292	*
293	* @param requiredSize
294	* @return
295	*/
296	private boolean isSizeAvailableToLoadColumnDictionary(long requiredSize) {
297	return lruCacheMemorySize >= (currentSize + requiredSize);	2✔
298	}
299
300	/**
301	* @param key
302	* @return
303	*/
304	public Cacheable get(String key) {
305	synchronized (lruCacheMap) {	2✔
306	return lruCacheMap.get(key);	2✔
307	}	×
308	}
309
310	/**
311	* This method will empty the level cache
312	*/
313	public void clear() {
314	synchronized (lruCacheMap) {	2✔
315	lruCacheMap.clear();	2✔
316	}	2✔
317	}	2✔
318
319	public Map<String, Cacheable> getCacheMap() {
320	return lruCacheMap;	1✔
321	}
322
323	/**
324	* Check if LRU cache setting is bigger than max memory of jvm.
325	* if LRU cache is bigger than max memory of jvm when query for a big segments table,
326	* may cause JDBC server crash.
327	* @return true LRU cache is bigger than max memory of jvm, false otherwise
328	*/
329	private boolean isBeyondMaxMemory() {
330	long mSize = Runtime.getRuntime().maxMemory();	2✔
331	long lruSize = lruCacheMemorySize * BYTE_CONVERSION_CONSTANT;	2✔
332	return lruSize >= mSize;	2✔
333	}
334
335	/**
336	* when LRU cache is bigger than max heap of jvm.
337	* set to part of max heap size, use CARBON_LRU_CACHE_PERCENT_OVER_MAX_SIZE default 60%.
338	* @return the LRU cache size
339	*/
340	private double getPartOfXmx() {
341	long mSizeMB = Runtime.getRuntime().maxMemory() / BYTE_CONVERSION_CONSTANT;	2✔
342	return mSizeMB * CarbonCommonConstants.CARBON_LRU_CACHE_PERCENT_OVER_MAX_SIZE;	2✔
343	}
344	}

apache / carbondata / 2887

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