लेकिन सार कुछ है, या स्रोत कोड को कम से कम लगता है जितना आसान लगता है।

इन अद्भुत जनवरी के दिनों में, हम सभी, निश्चित रूप से, हमलावर को बनाए रखते हुए स्रोत कोड को कम करने के मुद्दे के बारे में चिंतित हैं। मेरा मतलब है, परवाह नहीं है?!? व्यर्थ में ... यहां संकलक गिर गया, और कार्यक्रम विशाल है - यह डेवलपर्स के लिए ऐसी चीज भेजने के लिए किसी तरह असुविधाजनक है। और फिर मजा शुरू होता है: क्या होगा अगर आप इसे फेंक दें? ओह, यह गिरता नहीं है - ठीक है, हम इसे छोड़ देते हैं, लेकिन अगर यह हो तो क्या होगा? - अभी भी दुर्घटनाओं, और यह, और यह, और ... ओह, मैंने पुराने स्रोतों पर संकलक शुरू किया।

उसी समय, बगों की खोज को स्वचालित करना जीवन का मामला है: गिट बिसैक्ट, llvm-Bugpoint, क्रेडिट करें, ... इस लेख में मैं परीक्षण के मामले को सरल बनाने की समस्या को हल करने के लिए एक और तरीका बताऊंगा, प्रोग्रामिंग भाषा के संबंध में अधिक या कम सार्वभौमिक, और कुछ दिखाऊंगा उपयोग के उदाहरण।

यूनिवर्सल, कहते हैं ... हो सकता है, निश्चित रूप से, यह पहले से ही दस बार लागू किया गया हो, लेकिन क्या यह एक अनुभवी साइकिल चालक को रोक देगा। और जब एक माइक्रोस्कोप के हाथों में, सभी समस्याएं नाखून लगती हैं। माइक्रोस्कोप की भूमिका में - पीएमडी ।

सामान्य तौर पर, अंतर समीकरणों द्वारा वर्णित मॉडल लिखने के लिए एक ऐसी भाषा है - मॉडलिका। यह काफी उन्नत है, एक बहुत अच्छा खुला कार्यान्वयन है और सामान्य रूप से। लेकिन एक छोटी सी समस्या है: कभी-कभी एक आंतरिक संकलक त्रुटि संकलक में होती है। पिछले लेख में, मैंने पहले से ही दिखाया था कि मोडेला समर्थन को पीएमडी स्टेटिक विश्लेषक के साथ कैसे जोड़ा जाए (वैसे, समीक्षा प्रक्रिया के दौरान मेरी कुछ त्रुटियां सामने आईं) दस मौजूदा भाषा मॉड्यूलों के अलावा। तो अब मैंने फैसला किया - गायब होने के लिए क्या अच्छा है - और एक प्रूफ ऑफ-कॉन्सेप्ट टूल सोर्स कोड मिनीमाइज़र भेजा, जो मौजूदा लैंग्वेज मॉड्यूल डीएसडी का पुन: उपयोग कर रहा है। दुर्भाग्य से, मुझे एक पड़ोसी भंडार के पास, हालांकि बहुत दूर नहीं भेजा गया था: प्रस्तावक ने कहा कि वह अभी भी सदी के अंत तक इसका समर्थन करने का फैसला नहीं करता है, और यह आम कोड बेस में खो जाता है, इसलिए मुझे जल्द ही अपने इनबॉक्स में सहयोगी का निमंत्रण मिला हौसले से बनाया pmd / pmd-scm ।

सबसे पहले, समस्या का बयान क्या है? स्रोत कोड के आकार को कम करना आवश्यक है, इसकी कुछ संपत्ति को संरक्षित करना। अधिक विशेष रूप से, मैं चाहता हूं

• परिणामी कोड दूरदर्शी था
  
  • यह जितना संभव हो उतना कम से कम नहीं होना चाहिए, "फ़ाइल पूर्णता" अनुमेय है, लेकिन इसे पीड़ा में नहीं बदलना चाहिए
  • स्वत: स्थापन नहीं माना जाता है
• कम से कम प्रोग्राम को सोर्स कोड के साथ कई फाइलों में विभाजित किया जा सकता है
  
  • उदाहरण के लिए, जावा में, प्रत्येक public वर्ग को सही नाम आदि के साथ एक अलग फाइल में होना चाहिए।
  • मैं चाहता हूं कि प्रत्येक फ़ाइल अंत में दिखाई दे
• परिवर्तनों की प्रक्रिया में, संकेतित अपरिवर्तनीय को संरक्षित किया जाना चाहिए

आंतरिक उपकरण

इस अनुभाग में, मैं मोटे तौर पर कार्यान्वयन का वर्णन करूंगा। शुरू करने के लिए, मैं फिर से ध्यान देता हूं कि यह विचार, इसे हल्के ढंग से रखने के लिए, नया नहीं है। और अगर मैंने "स्वचालित डिबगिंग तंत्र" के एक उदाहरण के रूप में बस गिसेक्ट का उल्लेख किया है , तो मैं काफी समय के लिए क्रेडिट या कुछ समान आया (हालांकि मैंने इसका उपयोग नहीं किया था)। लेकिन मुझे llvm-bugpoint का उपयोग करना पड़ा - यह प्रभावशाली है: आप अपने LLVM पास को डीबग करते हैं, और यह - ऐसा संक्रमण - कुछ फ़ाइल सिस्टम पर क्रैश होता है। तो, आप इस फ़ाइल को LLVM बिटकोड में संकलित कर सकते हैं, अपने प्लगइन के साथ .bc फ़ाइल पर opt चलाएं और सुनिश्चित करें कि यह क्रैश हो गया है। और फिर, मोटे तौर पर, मैंने सिर्फ llvm-bugpoint साथ opt को बदल दिया, और एक मिनट के बाद मुझे एक फ़ंक्शन का एक "कंकाल" मिला, जिसमें आधार ब्लॉक और उनके बीच संक्रमण के बादल शामिल थे; सब कुछ लेकिन शाखाओं को सफलतापूर्वक फेंक दिया गया था। वैसे, समस्या के मेरे बयान में, मैनुअल सरलीकरण के एक दर्जन मिनट के बाद, यह सब इस तथ्य पर उतर आया कि मैंने गलत तरीके से शाखा प्रकारों में से एक को संसाधित किया, और बाकी सब सिर्फ दृश्य थे। सामान्य तौर पर, विचार नया नहीं है।

और अब कार्यान्वयन के लिए। चूंकि यह अधिक या कम सार्वभौमिक उपकरण माना जाता था, इसलिए मैं कुछ प्रकार की रूपरेखा बनाना चाहता था, जिसमें हम विभिन्न भाषाओं के अनुरूप कार्यान्वयन को क्रैम कर सकते थे। नतीजतन, दो बल्कि रूढ़िवादी अवधारणाएं सामने आईं:

• समर्थित आक्रमणकारी
• कम से कम रणनीति

अचल

उस संपत्ति के विकल्पों में से एक जिसे आप बचाना चाहते हैं, मैंने पहले ही वर्णित किया है: "संकलक ने एक वाक्यांश को कंसोल पर मुद्रित किया" ("आंतरिक संकलक त्रुटि", उदाहरण के लिए)। इसके अलावा, विचारों को कई प्रकार के फज़र्स से चमकाया जा सकता है: AFL , किलरबीज़ और अन्य:

• कुछ रिटर्न कोड के साथ प्रक्रिया समाप्त हो गई (विशेष रूप से, लिनक्स पर "सिग्नल पर दुर्घटना")
• इस प्रक्रिया में टी मिलीसेकंड से अधिक समय लगा। यहां, सिस्टम के फ्लोटिंग लोड के कारण अस्थिरता हो सकती है। अधिक सटीकता के लिए, आप CPU समय का उपयोग कर सकते हैं, हालांकि, आदर्श रूप से, प्रदर्शन काउंटर काम में आते हैं।
• संकलक कुछ आउटपुट फ़ाइल उत्पन्न (नहीं) कर सकता है
• ...

मैंने उनमें से कुछ को पहले ही लागू कर दिया है (वापसी कोड, मुद्रित लाइन), कुछ नहीं, कुछ व्यक्तिगत भाषाओं के लिए विशिष्ट हो सकते हैं। सामान्य तौर पर, यह कार्य का एक काफी स्वायत्त टुकड़ा है, जो अक्सर एक विशिष्ट भाषा से पूरी तरह से स्वतंत्र होता है।

न्यूनतम रणनीति

पहली नज़र में, यहाँ सब कुछ विशुद्ध रूप से भाषा-निर्भर है। कहीं-कहीं आपको उपयोग के मामलों के साथ-साथ चर को भी फेंकने की आवश्यकता है, कहीं - कहीं समान समीकरणों और अज्ञात की संख्या को बनाए रखने के लिए। सभी अधिक महत्वपूर्ण कोड के इस हिस्से को सार करना है। लेकिन कुछ बुनियादी को हर किसी के लिए सामान्य बनाया जा सकता है: उदाहरण के लिए, कलाई की एक चंचलता के साथ, XPath-rules इंजन बदल जाता है ... बदल जाता है ... ... ओह, XPath संस्करण 1.0 के लिए यह नहीं है। क्षमा करें, एक छोटी सी तकनीकी समस्या - वाक्यविन्यास पेड़ों को ट्रिम करने के लिए एक सार्वभौमिक उपकरण में सर्दियों के लिए । सामान्य तौर पर, न्यूनतम रणनीति एपीआई काफी सरल है: द्वारा और बड़े, फ़ंक्शन में एक चरण फ़ंक्शन होता है (इसे सिंटैक्स पेड़ों की जड़ नोड्स की एक सूची दी गई है), जो ऑपरेशन इंटरफ़ेस के माध्यम से "लेकिन इन शाखाओं को बाहर फेंकने की कोशिश" कर सकता है। यदि इनवेरिएंट का उल्लंघन किया जाता है, तो फ़ंक्शन नियंत्रण वापस कर देता है, यदि नहीं, तो यह एक विशेष अपवाद को फेंककर स्टैक को स्पिन करता है, और परिणामस्वरूप संस्करण अगले सन्निकटन के रूप में लिया जाता है। एक प्रक्रिया को पूर्ण माना जाता है यदि चरण फ़ंक्शन अपवाद के माध्यम से नियंत्रण वापस नहीं करता है। आप कह सकते हैं कि यह बहुत ही अप्रभावी है - शायद, ZATO CONVENIENT !! 111 , लेकिन यह सब क्या है, अगर यह नियमित रूप से बाहरी संकलक प्रक्रिया को एक चक्र में सैकड़ों बार शुरू करना है।

यह सवाल भी पैदा होता है: स्रोत को पतले एएसटी से वापस कैसे प्राप्त करें? बेशक, आप प्रत्येक भाषा के लिए एक विशेष कोड लिखने की कोशिश कर सकते हैं जो एक पाठ फ़ाइल उत्पन्न करता है। लेकिन, जैसा कि आप जानते हैं, एक प्रोग्रामर को आलसी होना चाहिए। इसलिए यह काम नहीं किया - यह पहले से ही स्पष्ट रूप से श्रृंखला से नहीं है "मौजूदा कार्यान्वयन को उठाया और जाना।" सौभाग्य से, पेड़ के नोड्स में इस नोड के लिए शुरुआत और अंत पंक्तियों और स्तंभों के बारे में जानकारी है - इसका मतलब है, यदि भाषा मॉड्यूल सही ढंग से इस जानकारी को इंगित करता है, तो आप स्रोत पाठ ले सकते हैं और ध्यान से टुकड़े काट सकते हैं (इसलिए, वैसे, और obfuscation के साथ कुछ कठिनाई: यह कुछ दूर फेंकने के लिए पर्याप्त नहीं है, लेकिन आपको इसे बदलने की आवश्यकता है: पहचानकर्ता, उदाहरण के लिए)। वैसे, पीएमडी कोड बेस में नॉन-इंटरसेक्टिंग टेक्स्ट कटिंग ऑपरेशन (और साथ ही जोड़कर, लेकिन इस विशेष कार्य के लिए यह इतना दिलचस्प नहीं है) के माध्यम से एक फ़ाइल को संपादित करने के लिए एक वर्ग भी था।

सिद्धांत: सारांश

फिलहाल मैंने दो रणनीतियां लागू की हैं। उनमें से एक XPath ट्रिमिंग है, जो कि, एक अर्थ में, एक पतित मामला है, क्योंकि यह जबरन परिणाम लिखता है, भले ही यह अब एक वाक्यात्मक सही स्रोत न हो। दूसरा पहले से ही "ईमानदार" पुनरावृत्त और संवादात्मक है (इस अर्थ में कि यह वास्तव में संकलक के साथ बातचीत करता है और इन्वर्टर की जांच करता है): यह सिर्फ एक लूप में एक-एक करके शाखाओं को फेंकने की कोशिश करता है। यहाँ इसके बारे में थोड़ा और अधिक है:

• सिद्धांत रूप में, स्रोत के लिए इन्वर्टर की जांच करना, जिसे पार्स नहीं किया गया है, एक "ईमानदार" रणनीति के लिए बहुत कम समझ में आता है: भले ही कंपाइलर इससे बच जाए, न्यूनतम को स्रोत को पुनरारंभ करना होगा। इसलिए, अग्रिम में "टूटी हुई" फाइलों को फेंकना समझ में आता है: आपकी प्रक्रिया में पार्स पूरे संकलक को चलाने की तुलना में किसी भी तेजी से होता है
• सामान्य स्थिति में, संभवतः यहां कॉरटाइन्स का उपयोग करना सुविधाजनक होगा (अच्छी तरह से, या बाहर नियंत्रण प्रवाह को चालू करें), लेकिन चूंकि यह काम के सबसे कम्प्यूटेशनल रूप से कठिन भाग से दूर है, चरण फ़ंक्शन में प्रत्येक चरण पर मैं बस पेड़ के चारों ओर चलता हूं, दूरी की गिनती करता हूं। सबसे ऊपर है। मुझे केवल काउंटर याद है। तो, पहले तो मैंने सोचा कि शीर्ष बड़ा है, शीर्ष कम है - इससे क्या फर्क पड़ता है, वैसे भी हेयुरिस्टिक! यह पता चला कि प्रति यूनिट त्रुटि कभी-कभी "अभिसरण" की दर को बदल सकती है। संक्षेप में, यह तर्कसंगत है: कक्षा से पूरे कार्यों को क्रम में फेंकना अक्सर एक प्रभावी रणनीति होगी। लेकिन फ़ंक्शन के अंदर जाने के लिए हर बार थोड़ा सा छोड़ना, और ज्यादातर मामलों में समस्या के साथ कुछ भी नहीं करने के लिए, यह एक तथाकथित विचार जैसा दिखता है।
• वैसे, कोरटाइन और नियंत्रण प्रवाह की तैनाती के बारे में: इसके साथ कुछ समस्याएं होंगी, क्योंकि परिवर्तित पाठ को रीबूट करने के बाद एएसटी बहुत स्पष्ट तरीके से नहीं बदल सकता है (अर्थात, न केवल इन शाखाओं को वापस फेंक दिया जाएगा, लेकिन कहीं-कहीं खाली नोड्स गायब हो जाएंगे, आम तौर पर पार्सिंग दूसरे रास्ते पर जाएगी)। यह उल्लेख नहीं करने के लिए कि नए एएसटी के नोड्स पुराने के संदर्भ में समान नहीं होंगे, और तार्किक मिलान equals - यह भी एक मुश्किल काम की तरह दिखता है
• सिद्धांत रूप में, आप पीएमडी की क्षमताओं को अलग-अलग डिग्री में उपयोग कर सकते हैं: आप गणना प्रकार, परिभाषा-उपयोग निर्भरता, आदि का उपयोग कर सकते हैं। और कुछ बहुत स्मार्ट करते हैं (लेकिन आपको एक सार्वभौमिक एपीआई पर विचार करने की आवश्यकता है)। दूसरी ओर, वर्णित रणनीति के लिए, एक पार्स ट्री प्राप्त करने के लिए पर्याप्त है। और यहाँ आप भी कुछ Kaitai संरचना हुक और बाइनरी फ़ाइलों को कम करने के लिए afl-tmin पुश करने की कोशिश कर सकते हैं :)

अभ्यास

आरंभ करने के लिए, चलो एक न्यूनतम निर्माण करते हैं:

 git clone https://github.com/pmd/pmd-scm.git cd pmd-scm ./mvnw clean verify unzip pmd-scm-dist/target/pmd-scm-bin-1.0.0-SNAPSHOT.zip 

अब आपको कुछ स्रोत चाहिए। उदाहरण के लिए GreedyStrategy.java को लेते हैं।

नियम डिजाइनर का उपयोग करना , यह पता लगाना कि जावा के लिए एक विशिष्ट एएसटी कैसा दिखता है, और चलाएं

 $ ./bin/run.sh scm --language java \ --input-file ../pmd-scm/src/main/java/net/sourceforge/pmd/scm/strategies/GreedyStrategy.java \ --output-file GreedyStrategy-min.java \ --strategy xpath \ --xpath-expression '//BlockStatement[count(../BlockStatement) > 1]' Original file(s): 6155 bytes, 1099 nodes. After initial white-space cleanup: size 4548 bytes (73%), 1099 nodes (100%) After pass #1: size 1984 bytes (32%), 1099 nodes (100%) After final white-space cleanup: size 1984 bytes (32%), 325 nodes (29%) After blank line clean up: size 1767 bytes (28%), 325 nodes (29%) 

 package net.sourceforge.pmd.scm.strategies; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import net.sourceforge.pmd.lang.ast.Node; public class GreedyStrategy extends AbstractMinimizationStrategy { public static class Configuration extends AbstractConfiguration { @Override public MinimizationStrategy createStrategy() { return new GreedyStrategy(this); } } public static final MinimizationStrategyConfigurationFactory FACTORY = new AbstractFactory("greedy") { @Override public MinimizationStrategyConfiguration createConfiguration() { return new Configuration(); } }; private GreedyStrategy(Configuration configuration) { super(configuration); } private final Map<Node, HashSet<Node>> directlyDependingNodes = new HashMap<>(); private final Map<Node, Set<Node>> transitivelyDependingNodes = new HashMap<>(); private void fetchDirectDependentsFromSubtree(Node node) { // process depending nodes } private Set<Node> indirectlyDependentNodesFor(Node currentNode) { } private void collectNodesToRemove(Set<Node> result, Node node) { } private int previousPosition = 0; private int positionCountdown; private void findNodeToRemove(Node currentNode) throws Exception { } private void processSingleRoot(Node currentRoot) throws Exception { // cannot remove root for (int i = 0; i < currentRoot.jjtGetNumChildren(); ++i) { findNodeToRemove(currentRoot.jjtGetChild(i)); } } @Override public void performSinglePass(List<Node> roots) throws Exception { } } 

यही है, हमने सभी कार्यों को एक से अधिक कथन से सीधे खाली कर दिया है। हालाँकि, टिप्पणियों, रिक्त लाइनों आदि को हटाना मैंने इसे निर्दिष्ट नहीं किया है - आखिरकार, यह (अब तक?) मुख्य रूप से डिबगिंग कंपाइलरों के लिए एक उपकरण है, बजाय सुंदर इंटरफ़ेस के निर्माण के।

आइए अब कुछ और दिलचस्प देखें: एक ही समय में संकलक से प्रतिक्रिया के साथ दो फ़ाइलों को कम करने का प्रयास करें:

मूल / TestResource.java:

 class TestResource { int func() { System.err.println("Hello World!"); return 123; } void unused() { // unused } } 

मूल / मुख्य.जावा:

 class Main { public static void main(String[] args) { String str = new TestResource().func(); return 123; } } 

जैसा कि आप देख सकते हैं, वे संकलन नहीं करते हैं:

 $ javac orig/TestResource.java orig/Main.java orig/Main.java:3: error: incompatible types: int cannot be converted to String String str = new TestResource().func(); ^ orig/Main.java:5: error: incompatible types: unexpected return value return 123; ^ 2 errors 

आइए कल्पना करें कि पहली त्रुटि के साथ कुछ गलत है, और एक न्यूनतम उदाहरण बनाने की कोशिश करें जो पैदा करता है

 error: incompatible types: int cannot be converted to String 

ऐसा करने के लिए, भागो

 $ bin/run.sh scm --language java \ --input-file orig/TestResource.java orig/Main.java \ --output-file TestResource.java Main.java \ --invariant message \ --printed-message "error: incompatible types: int cannot be converted to String"\ --command-line "javac TestResource.java Main.java" \ --strategy greedy Original file(s): 290 bytes, 77 nodes. After initial white-space cleanup: size 258 bytes (88%), 77 nodes (100%) After pass #1: size 255 bytes (87%), 64 nodes (83%) After pass #2: size 244 bytes (84%), 57 nodes (74%) After pass #3: size 205 bytes (70%), 51 nodes (66%) After pass #4: size 192 bytes (66%), 46 nodes (59%) After pass #5: size 181 bytes (62%), 39 nodes (50%) After pass #6: size 179 bytes (61%), 39 nodes (50%) After final white-space cleanup: size 149 bytes (51%), 39 nodes (50%) After blank line clean up: size 147 bytes (50%), 39 nodes (50%) 

नतीजतन, हम प्राप्त करते हैं

TestResource.java:

 class TestResource { int func() { } } 

Main.java:

 class Main { public static void main() { String str = new TestResource().func(); } } 

 $ javac TestResource.java Main.java TestResource.java:3: error: missing return statement } ^ Main.java:3: error: incompatible types: int cannot be converted to String String str = new TestResource().func(); ^ 2 errors 

आदेश के अनुसार सब कुछ!

परिणाम

अब तक, परियोजना काफी प्रारंभिक चरण में है, लेकिन प्रदर्शन करने के लिए पहले से ही कुछ है। भविष्य में, एएसटी नोड्स के बीच निर्भरता को इंगित करने वाली भाषा अज्ञेय के लिए एक एपीआई बनाने के लिए विचार हैं, जिससे भाषा-विशिष्ट रणनीतियों को प्रदान करना संभव हो सके। एक सार्वभौमिक रणनीति बनाना अच्छा होगा जो ग्रूवी / कोटलिन / स्क्रिप्ट को कुछ और चलाता है - आखिरकार, जो लोग जावा का उपयोग करते हैं, उन्होंने इसे कभी नहीं देखा होगा, लेकिन वे पूरी तरह से अच्छी तरह से जानते हैं, उदाहरण के लिए, मॉडलिका, और स्रोत को निचोड़ने के लिए उनके उन्नत तरीके उनके सिर में हैं।