[ https://issues.apache.org/jira/browse/DRILL-5052?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15732487#comment-15732487 ]
ASF GitHub Bot commented on DRILL-5052: --------------------------------------- Github user arina-ielchiieva commented on a diff in the pull request: https://github.com/apache/drill/pull/660#discussion_r91276697 --- Diff: exec/java-exec/src/main/java/org/apache/drill/exec/compile/CachedClassLoader.java --- @@ -0,0 +1,70 @@ +/** + * 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.drill.exec.compile; + +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Map; +import java.util.concurrent.ConcurrentMap; + +import com.google.common.collect.MapMaker; + +/** + * Class loader for "plain-old Java" generated classes. + * Very basic implementation: allows defining a class from + * byte codes and finding the loaded classes. Delegates + * all other class requests to the thread context class + * loader. This structure ensures that a generated class can + * find both its own inner classes as well as all the standard + * Drill implementation classes. + */ + +public class CachedClassLoader extends URLClassLoader { + + /** + * Cache of generated classes. Semantics: a single thread defines + * the classes, many threads may access the classes. + */ + + private ConcurrentMap<String, Class<?>> cache = new MapMaker().concurrencyLevel(4).makeMap(); + + public CachedClassLoader( ) { + super(new URL[0], Thread.currentThread().getContextClassLoader()); + } + + public void addClass( String fqcn, byte[] byteCodes ) { + + assert ! cache.containsKey( fqcn ); + Class<?> newClass = defineClass(fqcn, byteCodes, 0, byteCodes.length); + cache.put( fqcn, newClass ); + } + + @Override + public Class<?> findClass(String className) throws ClassNotFoundException { + Class<?> theClass = cache.get( className ); + if ( theClass != null ) { + return theClass; } + return super.findClass(className); + } + + public void addClasses(Map<String, byte[]> results) { + for ( String key : results.keySet() ) { + addClass( key, results.get( key ) ); + } --- End diff -- Using iteration over map via entry set is more efficient than via key set: for (Map.Entry<String, byte[]> result : results.entrySet()) { addClass(result.getKey(), result.getValue()); } > Option to debug generated Java code using an IDE > ------------------------------------------------ > > Key: DRILL-5052 > URL: https://issues.apache.org/jira/browse/DRILL-5052 > Project: Apache Drill > Issue Type: Improvement > Components: Execution - Codegen > Affects Versions: 1.8.0 > Reporter: Paul Rogers > Assignee: Paul Rogers > Priority: Minor > > Drill makes extensive use of Java code generation to implement its operators. > Drill uses sophisticated techniques to blend generated code with pre-compiled > template code. An unfortunate side-effect of this behavior is that it is very > difficult to visualize and debug the generated code. > As it turns out, Drill's code-merge facility is, in essence, a do-it-yourself > version of subclassing. The Drill "template" is the parent class, the > generated code is the subclass. But, rather than using plain-old subclassing, > Drill combines the code from the two classes into a single "artificial" > packet of byte codes for which no source exists. > Modify the code generation path to optionally allow "plain-old Java" > compilation: the generated code is a subclass of the template. Compile the > generated code as a plain-old Java class with no byte-code fix-up. Write the > code to a known location that the IDE can search when looking for source > files. > With this change, developers can turn on the above feature, set a breakpoint > in a template, then step directly into the generated Java code called from > the template. > This feature should be an option, enabled by developers when needed. The > existing byte-code technique should be used for production code generation. -- This message was sent by Atlassian JIRA (v6.3.4#6332)