সংযুক্ত খালিগুলিতে জাভা স্যুইচ কেন যোগ হওয়া মামলার সাথে দ্রুত চালিত হয়?

276

আমি এমন কিছু জাভা কোড নিয়ে কাজ করছি যা এটির জন্য উচ্চতর অনুকূলিতকরণ হওয়া দরকার কারণ এটি আমার মূল প্রোগ্রামটির যুক্তিতে বহু পয়েন্টে অনুরোধ করা হট ফাংশনগুলিতে চলবে। এই কোডের অংশে স্বেচ্ছাসেবক অ-নেতিবাচক গুলিগুলিকে উত্থিত করে গুণকগুলি গুণিত doubleকরে । এক দ্রুত উপায় (সম্পাদনা: কিন্তু না দ্রুততম সম্ভব, নীচের আপডেট 2 দেখুন) বহুগুণ মান হয় পেতে উপর :10int exponentswitchexponent

double multiplyByPowerOfTen(final double d, final int exponent) {
   switch (exponent) {
      case 0:
         return d;
      case 1:
         return d*10;
      case 2:
         return d*100;
      // ... same pattern
      case 9:
         return d*1000000000;
      case 10:
         return d*10000000000L;
      // ... same pattern with long literals
      case 18:
         return d*1000000000000000000L;
      default:
         throw new ParseException("Unhandled power of ten " + power, 0);
   }
}

উপরে মন্তব্য করা উপবৃত্তগুলি ইঙ্গিত দেয় যে case intধ্রুবকগুলি 1 দ্বারা বৃদ্ধি অবিরত করে, সুতরাং caseউপরের কোড স্নিপেটে সত্যই 19 টি রয়েছে। যেহেতু আমি নিশ্চিত কিনা আমি আসলে 10 সকল ক্ষমতার প্রয়োজন হবে ছিল না caseবিবৃতি 10পুরনো 18, আমি সম্পূর্ণ 10 মিলিয়ন অপারেশন করার সময় এই সঙ্গে তুলনা microbenchmarks দৌড়ে switchবক্তব্য বনাম switchশুধুমাত্র সঙ্গে caseগুলি 0পুরনো 9সঙ্গে ( exponentকম 9 বা সীমাবদ্ধ পেয়ারড ডাউন ভাঙ্গা এড়ান switch)। আমি বরং অবাক করে দিয়েছি (আমার কাছে, কমপক্ষে!) ফলস্বরূপ যে switchআরও caseবিবৃতি সহকারে দীর্ঘতর ঘটনাটি দ্রুত চলে।

একটি লার্কে, আমি আরও বেশি caseএস যুক্ত করার চেষ্টা করেছি যা সবেমাত্র ডামি মানগুলি ফিরিয়ে দিয়েছে এবং আমি দেখতে পেয়েছি যে প্রায় 22-27 ঘোষিত এসের সাথে আমি আরও দ্রুত গতিতে চলে যেতে পারি case(যদিও কোডটি চলাকালীন সেই ডামি মামলাগুলি আসলে কখনও আঘাত হয় না) )। (আবার, caseপূর্ববর্তী caseধ্রুবক দ্বারা বর্ধিত করে একটি সামঞ্জস্যপূর্ণ ফ্যাশনে এস যুক্ত করা হয়েছিল 1)) এই মৃত্যুদন্ড কার্যকর করার সময় পার্থক্য খুব বেশি তাৎপর্যপূর্ণ নয়:exponent মধ্যে একটি এলোমেলো 0এবং10 , ডামি প্যাডেড switchবিবৃতি 10 মিলিয়ন মৃত্যুদণ্ড কার্যকর 1.49 সেকেন্ডের মধ্যে বনাম unpadded জন্য 1.54 সেকেন্ড শেষ সংস্করণ, প্রতিটি কার্যকর কার্যকর 5ns এর বিশাল সঞ্চয় sav সুতরাং, যে ধরণের জিনিসটি প্যাডিং আউটকে আচ্ছন্ন করে তোলে notswitchএকটি অপ্টিমাইজেশন অবস্থান থেকে প্রচেষ্টা মূল্যবান বিবৃতি। তবে আমি এখনও এটি কৌতূহলী এবং পাল্টা স্বজ্ঞাত হিসাবে খুঁজে পেয়েছি যে এর সাথে আরও বেশি যুক্ত হওয়ার সাথে সাথে কার্যকর করার জন্য switchকোনও ধীর হয়ে যায় না (বা সম্ভবত সেরা ধ্রুবক O (1) সময় বজায় রাখতে পারে) case।

বেঞ্চমার্কিংয়ের ফলাফলগুলি স্যুইচ করুন

এলোমেলোভাবে উত্পন্ন exponentমানগুলিতে বিভিন্ন সীমা নিয়ে চালানো থেকে প্রাপ্ত ফলাফলগুলি । আমি ফলাফলে নিচে সব পথ অন্তর্ভুক্ত করা হয়নি 1জন্য exponentসীমা, কিন্তু বক্ররেখা সাধারণ আকৃতি অবশেষ একই, 12-17 ক্ষেত্রে চিহ্ন কাছাকাছি একটি শৈলশিরা, এবং 18-28 মধ্যে একটি উপত্যকা সঙ্গে। অভিন্ন পরীক্ষার ইনপুটগুলি নিশ্চিত করার জন্য এলোমেলো মানগুলির জন্য ভাগ করা কন্টেইনারগুলি ব্যবহার করে সমস্ত পরীক্ষা JUnitBenchmark এ পরিচালিত হয়েছিল। switchঅর্ডার-সম্পর্কিত পরীক্ষার সমস্যার ক্রমবিন্যাসের সম্ভাবনা এবং চেষ্টা বাদ দেওয়ার জন্য আমি দীর্ঘতম বিবৃতি থেকে স্বল্পতম পর্যন্ত এবং তদ্বিপরীত উভয়ই পরীক্ষাগুলি চালিয়েছি। যদি কেউ এই ফলাফলগুলি পুনরুত্পাদন করার চেষ্টা করতে চায় তবে আমি আমার পরীক্ষার কোডটি একটি গিথুব রেপোতে রেখেছি।

তো, এখানে কি চলছে? আমার আর্কিটেকচার বা মাইক্রো-বেঞ্চমার্ক নির্মাণের কিছু বিকাশ? বা জাভা হয় switchসত্যিই একটু দ্রুত মধ্যে চালানো 18থেকে 28 caseপরিসীমা তুলনায় এটি থেকে 11আপ 17?

গিথুব টেস্ট রেপো "স্যুইচ-এক্সপেরিমেন্ট"

আপডেট: আমি বেঞ্চমার্কিং লাইব্রেরিটি বেশ খানিকটা পরিষ্কার করেছি এবং সম্ভাব্য exponentমানের বিস্তৃত পরিসীমা জুড়ে কিছু ফলাফল দিয়ে / ফলাফলগুলিতে একটি পাঠ্য ফাইল যুক্ত করেছি । আমিও পরীক্ষামূলক কোড একটি নিক্ষেপ না করতে একটি বিকল্প যোগ Exceptionথেকে default, কিন্তু এই ফলাফল প্রভাবিত করার মনে হচ্ছে না।

আপডেট 2: xkcd ফোরামে ২০০৯ এর পূর্ব থেকে এই ইস্যুটির বেশ কিছু সুন্দর আলোচনা এখানে পেয়েছে: http://forums.xkcd.com/viewtopic.php?f=11&t=33524 । ওপির ব্যবহার সম্পর্কে আলোচনা Array.binarySearch()আমাকে উপরের এক্সপেনসিয়েশন প্যাটার্নটির একটি সহজ অ্যারে-ভিত্তিক প্রয়োগের জন্য ধারণা দিয়েছে। বাইনারি অনুসন্ধানের কোনও প্রয়োজন নেই যেহেতু আমি জানি যেগুলিতে কী কী প্রবেশিকা arrayরয়েছে। এটি ব্যবহারের চেয়ে প্রায় 3 গুণ বেশি দ্রুত চলবে বলে মনে হয় switch, কিছু নিয়ন্ত্রণ প্রবাহকে সরবরাহ করে যা স্পষ্টভাবেই switchসরবরাহ করে। সেই কোডটি গিথুব রেপোতেও যুক্ত করা হয়েছে।

java  performance  assembly  compiler-construction  switch-statement 
— অ্যান্ড্রু বিসেল
সূত্র
64
এখন সমস্ত গুগলারের কাছে সমস্ত switchবিবৃতিতে অবশ্যই 22 টি মামলা থাকবে , কারণ এটি স্পষ্টভাবে সর্বাধিক অনুকূল সমাধান। : ডি (এটি আমার নেতৃত্বের দিকে দেখাবেন না, দয়া করে))
— অ্যাসটারি
2
আপনার কি সহজ এসএসসিসিই আছে? এটি আমার জন্য সংকলন করে না। আমি জাভা পারফরম্যান্সের সাথে যতটা দুর্বল, আমি এটায় শট নিতে চাই।
— রহস্যময়
5
আপনি স্ট্রিং-ভিত্তিক ক্ষেত্রেগুলি সম্পর্কে আমার উত্তরে "জেভিএম-এ স্যুইচস" বিভাগটি সন্ধান করতে পারেন । আমি মনে করি এখানে কি ঘটছে সে যে আপনি একটি থেকে সুইচিং হয় lookupswitchএকটি থেকে tableswitch। আপনার কোডটি বিচ্ছিন্ন করে দেওয়া javapআপনাকে অবশ্যই নিশ্চিত করবে।
— এরিকসন
2
আমি রেপোতে / lib ফোল্ডারে নির্ভরতা জারগুলি যুক্ত করেছি। @ রহস্যময় দুঃখিত, আমি ইতিমধ্যে এই খরগোশের গর্তটি নেমে যাওয়ার জন্য বেশিরভাগ সময় ব্যয় করেছি! যদি আপনি পরীক্ষার ক্লাস বন্ধ করে "এক্সট্রেড অ্যাবস্ট্রাকব্যাঞ্চমার্ক" নেন এবং "com.carrotsearch" আমদানি থেকে মুক্তি পান তবে আপনি কেবল JUnit নির্ভরতা নিয়ে চালাতে পারেন, তবে জেআইটি থেকে কিছু শব্দকে ফিল্টার করার জন্য ক্যারোটসার্ক স্টাফ বেশ সুন্দর is এবং ওয়ার্মআপ পিরিয়ড। দুর্ভাগ্যক্রমে আমি জানি না যে কীভাবে ইন্টেলিজের বাইরে এই JUnit পরীক্ষা চালানো যায়।
— অ্যান্ড্রু বিসেল
2
@ অ্যান্ড্রুবিসেল আমি আপনার ফলাফলগুলিকে আরও সরল মাপদণ্ডের সাথে পুনঃস্থাপন করতে পেরেছি। ছোট বনাম মাঝারি আকারের পারফরম্যান্সের জন্য শাখা বনাম টেবিলটি কিছুটা সুস্পষ্ট অনুমান ছিল। তবে 30 টি মামলায় নিমজ্জন সম্পর্কে আমার আর কারও চেয়ে ভাল অন্তর্দৃষ্টি নেই ...
— রহস্যময়

উত্তর:

228

অন্য উত্তরের দ্বারা নির্দেশিত হিসাবে , যেহেতু কেস মানগুলি সংক্ষিপ্ত (বিস্ফোরকের বিপরীতে), আপনার বিভিন্ন পরীক্ষার জন্য উত্পন্ন বাইকোড একটি স্যুইচ টেবিল (বাইটকোড নির্দেশ tableswitch) ব্যবহার করে।

যাইহোক, একবার জেআইটি তার কাজ শুরু করে এবং বাইটকোডকে অ্যাসেমব্লিতে সংকলন করে, tableswitchনির্দেশের ফলে সর্বদা পয়েন্টারগুলির একটি অ্যারে তৈরি হয় না: কখনও কখনও স্যুইচ টেবিলটি দেখতে যেমন রূপান্তরিত হয় lookupswitch(একটি if/ else ifকাঠামোর অনুরূপ )।

জেআইটি (হটস্পট জেডিকে ১.7) দ্বারা উত্পন্ন অ্যাসেমব্লিকে ডিসেম্পলিং করে দেখায় যে এটি যদি / অন্যথায় 17 টি মামলা বা তার চেয়ে কম ক্ষেত্রে থাকে, যখন 18 টিরও বেশি (আরও দক্ষ) থাকে তখন পয়েন্টারের একটি অ্যারে ব্যবহার করা হয় success

18 টির এই ম্যাজিক নম্বরটি যে কারণে ব্যবহৃত হয়েছে তা MinJumpTableSizeJVM পতাকার ডিফল্ট মান (কোডটিতে 352 লাইনের আশেপাশে) নেমে এসেছে বলে মনে হচ্ছে ।

আমি হটস্পট সংকলক তালিকায় বিষয়টি উত্থাপন করেছি এবং এটি অতীত পরীক্ষার উত্তরাধিকার বলে মনে হচ্ছে । নোট করুন যে আরও বেশি বেঞ্চমার্কিংয়ের পরে জেডিকে 8 এ এই ডিফল্ট মানটি সরানো হয়েছে ।

অবশেষে, যখন পদ্ধতিটি দীর্ঘ হয়ে যায় (> আমার পরীক্ষাগুলিতে 25 টি কেস), এটি আর ডিফল্ট জেভিএম সেটিংসের সাথে আর অন্তর্ভুক্ত থাকে না - এটি সেই সময়ে কর্মক্ষমতা হ্রাসের সর্বাপেক্ষা গুরুত্বপূর্ণ কারণ।

৫ টি কেস সহ, ডিসপম্পলড কোডটি দেখতে দেখতে (সিএমপি / জে / জেজি / জেএমপি নির্দেশাবলীর নোটিশ, যদি / গোটো হয় তার জন্য সমাবেশটি দেখুন):

[Verified Entry Point]
  # {method} 'multiplyByPowerOfTen' '(DI)D' in 'javaapplication4/Test1'
  # parm0:    xmm0:xmm0   = double
  # parm1:    rdx       = int
  #           [sp+0x20]  (sp of caller)
  0x00000000024f0160: mov    DWORD PTR [rsp-0x6000],eax
                                                ;   {no_reloc}
  0x00000000024f0167: push   rbp
  0x00000000024f0168: sub    rsp,0x10           ;*synchronization entry
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@-1 (line 56)
  0x00000000024f016c: cmp    edx,0x3
  0x00000000024f016f: je     0x00000000024f01c3
  0x00000000024f0171: cmp    edx,0x3
  0x00000000024f0174: jg     0x00000000024f01a5
  0x00000000024f0176: cmp    edx,0x1
  0x00000000024f0179: je     0x00000000024f019b
  0x00000000024f017b: cmp    edx,0x1
  0x00000000024f017e: jg     0x00000000024f0191
  0x00000000024f0180: test   edx,edx
  0x00000000024f0182: je     0x00000000024f01cb
  0x00000000024f0184: mov    ebp,edx
  0x00000000024f0186: mov    edx,0x17
  0x00000000024f018b: call   0x00000000024c90a0  ; OopMap{off=48}
                                                ;*new  ; - javaapplication4.Test1::multiplyByPowerOfTen@72 (line 83)
                                                ;   {runtime_call}
  0x00000000024f0190: int3                      ;*new  ; - javaapplication4.Test1::multiplyByPowerOfTen@72 (line 83)
  0x00000000024f0191: mulsd  xmm0,QWORD PTR [rip+0xffffffffffffffa7]        # 0x00000000024f0140
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@52 (line 62)
                                                ;   {section_word}
  0x00000000024f0199: jmp    0x00000000024f01cb
  0x00000000024f019b: mulsd  xmm0,QWORD PTR [rip+0xffffffffffffff8d]        # 0x00000000024f0130
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@46 (line 60)
                                                ;   {section_word}
  0x00000000024f01a3: jmp    0x00000000024f01cb
  0x00000000024f01a5: cmp    edx,0x5
  0x00000000024f01a8: je     0x00000000024f01b9
  0x00000000024f01aa: cmp    edx,0x5
  0x00000000024f01ad: jg     0x00000000024f0184  ;*tableswitch
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (line 56)
  0x00000000024f01af: mulsd  xmm0,QWORD PTR [rip+0xffffffffffffff81]        # 0x00000000024f0138
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@64 (line 66)
                                                ;   {section_word}
  0x00000000024f01b7: jmp    0x00000000024f01cb
  0x00000000024f01b9: mulsd  xmm0,QWORD PTR [rip+0xffffffffffffff67]        # 0x00000000024f0128
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@70 (line 68)
                                                ;   {section_word}
  0x00000000024f01c1: jmp    0x00000000024f01cb
  0x00000000024f01c3: mulsd  xmm0,QWORD PTR [rip+0xffffffffffffff55]        # 0x00000000024f0120
                                                ;*tableswitch
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (line 56)
                                                ;   {section_word}
  0x00000000024f01cb: add    rsp,0x10
  0x00000000024f01cf: pop    rbp
  0x00000000024f01d0: test   DWORD PTR [rip+0xfffffffffdf3fe2a],eax        # 0x0000000000430000
                                                ;   {poll_return}
  0x00000000024f01d6: ret

18 টি ক্ষেত্রে, সমাবেশটি দেখতে এরকম দেখাচ্ছে (পয়েন্টারগুলির অ্যারেটি লক্ষ্য করুন যা ব্যবহৃত হয় এবং সমস্ত তুলনার প্রয়োজনকে দমন করে: jmp QWORD PTR [r8+r10*1]সরাসরি ডান গুণে লাফ দেয়) - এটি পারফরম্যান্স উন্নতির সম্ভাব্য কারণ:

[Verified Entry Point]
  # {method} 'multiplyByPowerOfTen' '(DI)D' in 'javaapplication4/Test1'
  # parm0:    xmm0:xmm0   = double
  # parm1:    rdx       = int
  #           [sp+0x20]  (sp of caller)
  0x000000000287fe20: mov    DWORD PTR [rsp-0x6000],eax
                                                ;   {no_reloc}
  0x000000000287fe27: push   rbp
  0x000000000287fe28: sub    rsp,0x10           ;*synchronization entry
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@-1 (line 56)
  0x000000000287fe2c: cmp    edx,0x13
  0x000000000287fe2f: jae    0x000000000287fe46
  0x000000000287fe31: movsxd r10,edx
  0x000000000287fe34: shl    r10,0x3
  0x000000000287fe38: movabs r8,0x287fd70       ;   {section_word}
  0x000000000287fe42: jmp    QWORD PTR [r8+r10*1]  ;*tableswitch
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (line 56)
  0x000000000287fe46: mov    ebp,edx
  0x000000000287fe48: mov    edx,0x31
  0x000000000287fe4d: xchg   ax,ax
  0x000000000287fe4f: call   0x00000000028590a0  ; OopMap{off=52}
                                                ;*new  ; - javaapplication4.Test1::multiplyByPowerOfTen@202 (line 96)
                                                ;   {runtime_call}
  0x000000000287fe54: int3                      ;*new  ; - javaapplication4.Test1::multiplyByPowerOfTen@202 (line 96)
  0x000000000287fe55: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe8b]        # 0x000000000287fce8
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@194 (line 92)
                                                ;   {section_word}
  0x000000000287fe5d: jmp    0x000000000287ff16
  0x000000000287fe62: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe86]        # 0x000000000287fcf0
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@188 (line 90)
                                                ;   {section_word}
  0x000000000287fe6a: jmp    0x000000000287ff16
  0x000000000287fe6f: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe81]        # 0x000000000287fcf8
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@182 (line 88)
                                                ;   {section_word}
  0x000000000287fe77: jmp    0x000000000287ff16
  0x000000000287fe7c: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe7c]        # 0x000000000287fd00
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@176 (line 86)
                                                ;   {section_word}
  0x000000000287fe84: jmp    0x000000000287ff16
  0x000000000287fe89: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe77]        # 0x000000000287fd08
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@170 (line 84)
                                                ;   {section_word}
  0x000000000287fe91: jmp    0x000000000287ff16
  0x000000000287fe96: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe72]        # 0x000000000287fd10
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@164 (line 82)
                                                ;   {section_word}
  0x000000000287fe9e: jmp    0x000000000287ff16
  0x000000000287fea0: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe70]        # 0x000000000287fd18
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@158 (line 80)
                                                ;   {section_word}
  0x000000000287fea8: jmp    0x000000000287ff16
  0x000000000287feaa: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe6e]        # 0x000000000287fd20
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@152 (line 78)
                                                ;   {section_word}
  0x000000000287feb2: jmp    0x000000000287ff16
  0x000000000287feb4: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe24]        # 0x000000000287fce0
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@146 (line 76)
                                                ;   {section_word}
  0x000000000287febc: jmp    0x000000000287ff16
  0x000000000287febe: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe6a]        # 0x000000000287fd30
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@140 (line 74)
                                                ;   {section_word}
  0x000000000287fec6: jmp    0x000000000287ff16
  0x000000000287fec8: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe68]        # 0x000000000287fd38
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@134 (line 72)
                                                ;   {section_word}
  0x000000000287fed0: jmp    0x000000000287ff16
  0x000000000287fed2: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe66]        # 0x000000000287fd40
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@128 (line 70)
                                                ;   {section_word}
  0x000000000287feda: jmp    0x000000000287ff16
  0x000000000287fedc: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe64]        # 0x000000000287fd48
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@122 (line 68)
                                                ;   {section_word}
  0x000000000287fee4: jmp    0x000000000287ff16
  0x000000000287fee6: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe62]        # 0x000000000287fd50
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@116 (line 66)
                                                ;   {section_word}
  0x000000000287feee: jmp    0x000000000287ff16
  0x000000000287fef0: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe60]        # 0x000000000287fd58
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@110 (line 64)
                                                ;   {section_word}
  0x000000000287fef8: jmp    0x000000000287ff16
  0x000000000287fefa: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe5e]        # 0x000000000287fd60
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@104 (line 62)
                                                ;   {section_word}
  0x000000000287ff02: jmp    0x000000000287ff16
  0x000000000287ff04: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe5c]        # 0x000000000287fd68
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@98 (line 60)
                                                ;   {section_word}
  0x000000000287ff0c: jmp    0x000000000287ff16
  0x000000000287ff0e: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe12]        # 0x000000000287fd28
                                                ;*tableswitch
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (line 56)
                                                ;   {section_word}
  0x000000000287ff16: add    rsp,0x10
  0x000000000287ff1a: pop    rbp
  0x000000000287ff1b: test   DWORD PTR [rip+0xfffffffffd9b00df],eax        # 0x0000000000230000
                                                ;   {poll_return}
  0x000000000287ff21: ret

এবং অবশেষে 30 কেস (নীচে) সহ অ্যাসেমব্লিটি 18 কেসের মতো দেখায়, movapd xmm0,xmm1কোডের মধ্যবর্তী দিকে প্রদর্শিত অতিরিক্ত ব্যতীত , @ সিএইচও দ্বারা চিহ্নিত হিসাবে দেখা যায় - তবে কার্যকারিতা হ্রাসের সম্ভবততম কারণটি হচ্ছে পদ্ধতিটি খুব বেশি ডিফল্ট জেভিএম সেটিংসের সাথে অন্তর্ভুক্ত হতে আগ্রহী:

[Verified Entry Point]
  # {method} 'multiplyByPowerOfTen' '(DI)D' in 'javaapplication4/Test1'
  # parm0:    xmm0:xmm0   = double
  # parm1:    rdx       = int
  #           [sp+0x20]  (sp of caller)
  0x0000000002524560: mov    DWORD PTR [rsp-0x6000],eax
                                                ;   {no_reloc}
  0x0000000002524567: push   rbp
  0x0000000002524568: sub    rsp,0x10           ;*synchronization entry
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@-1 (line 56)
  0x000000000252456c: movapd xmm1,xmm0
  0x0000000002524570: cmp    edx,0x1f
  0x0000000002524573: jae    0x0000000002524592  ;*tableswitch
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (line 56)
  0x0000000002524575: movsxd r10,edx
  0x0000000002524578: shl    r10,0x3
  0x000000000252457c: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe3c]        # 0x00000000025243c0
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@364 (line 118)
                                                ;   {section_word}
  0x0000000002524584: movabs r8,0x2524450       ;   {section_word}
  0x000000000252458e: jmp    QWORD PTR [r8+r10*1]  ;*tableswitch
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@1 (line 56)
  0x0000000002524592: mov    ebp,edx
  0x0000000002524594: mov    edx,0x31
  0x0000000002524599: xchg   ax,ax
  0x000000000252459b: call   0x00000000024f90a0  ; OopMap{off=64}
                                                ;*new  ; - javaapplication4.Test1::multiplyByPowerOfTen@370 (line 120)
                                                ;   {runtime_call}
  0x00000000025245a0: int3                      ;*new  ; - javaapplication4.Test1::multiplyByPowerOfTen@370 (line 120)
  0x00000000025245a1: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe27]        # 0x00000000025243d0
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@358 (line 116)
                                                ;   {section_word}
  0x00000000025245a9: jmp    0x0000000002524744
  0x00000000025245ae: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe22]        # 0x00000000025243d8
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@348 (line 114)
                                                ;   {section_word}
  0x00000000025245b6: jmp    0x0000000002524744
  0x00000000025245bb: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe1d]        # 0x00000000025243e0
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@338 (line 112)
                                                ;   {section_word}
  0x00000000025245c3: jmp    0x0000000002524744
  0x00000000025245c8: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe18]        # 0x00000000025243e8
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@328 (line 110)
                                                ;   {section_word}
  0x00000000025245d0: jmp    0x0000000002524744
  0x00000000025245d5: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe13]        # 0x00000000025243f0
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@318 (line 108)
                                                ;   {section_word}
  0x00000000025245dd: jmp    0x0000000002524744
  0x00000000025245e2: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe0e]        # 0x00000000025243f8
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@308 (line 106)
                                                ;   {section_word}
  0x00000000025245ea: jmp    0x0000000002524744
  0x00000000025245ef: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe09]        # 0x0000000002524400
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@298 (line 104)
                                                ;   {section_word}
  0x00000000025245f7: jmp    0x0000000002524744
  0x00000000025245fc: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe04]        # 0x0000000002524408
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@288 (line 102)
                                                ;   {section_word}
  0x0000000002524604: jmp    0x0000000002524744
  0x0000000002524609: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffdff]        # 0x0000000002524410
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@278 (line 100)
                                                ;   {section_word}
  0x0000000002524611: jmp    0x0000000002524744
  0x0000000002524616: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffdfa]        # 0x0000000002524418
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@268 (line 98)
                                                ;   {section_word}
  0x000000000252461e: jmp    0x0000000002524744
  0x0000000002524623: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffd9d]        # 0x00000000025243c8
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@258 (line 96)
                                                ;   {section_word}
  0x000000000252462b: jmp    0x0000000002524744
  0x0000000002524630: movapd xmm0,xmm1
  0x0000000002524634: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffe0c]        # 0x0000000002524448
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@242 (line 92)
                                                ;   {section_word}
  0x000000000252463c: jmp    0x0000000002524744
  0x0000000002524641: movapd xmm0,xmm1
  0x0000000002524645: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffddb]        # 0x0000000002524428
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@236 (line 90)
                                                ;   {section_word}
  0x000000000252464d: jmp    0x0000000002524744
  0x0000000002524652: movapd xmm0,xmm1
  0x0000000002524656: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffdd2]        # 0x0000000002524430
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@230 (line 88)
                                                ;   {section_word}
  0x000000000252465e: jmp    0x0000000002524744
  0x0000000002524663: movapd xmm0,xmm1
  0x0000000002524667: mulsd  xmm0,QWORD PTR [rip+0xfffffffffffffdc9]        # 0x0000000002524438
                                                ;*dmul
                                                ; - javaapplication4.Test1::multiplyByPowerOfTen@224 (line 86)
                                                ;   {section_word}

[etc.]

  0x0000000002524744: add    rsp,0x10
  0x0000000002524748: pop    rbp
  0x0000000002524749: test   DWORD PTR [rip+0xfffffffffde1b8b1],eax        # 0x0000000000340000
                                                ;   {poll_return}
  0x000000000252474f: ret
— assylias
সূত্র
7
@ syb0rg সত্যি কথা বলতে আমি জরিমানা
— বিবরণটিও
4
দুর্দান্ত উত্তরের জন্য +1! যখন ওপির চার্টে পারফরম্যান্স "ডিপ" থেকে বেরিয়ে আসে তখন আপনি তুলনা করার জন্য 30+ কেসের সাথে কিছু বিচ্ছিন্ন করতে পারেন?
— asteri
4
— assylias
2
@ অ্যান্ড্রুবিসেল আমার অনুমান যে পৃথক আচরণ উভয়ই (i) ক্রস-আর্কিটেকচার পারফরম্যান্স পরীক্ষার উপর ভিত্তি করে দেখা গেছে যে পয়েন্টারের অ্যারে কেবলমাত্র দক্ষ যখন ক্ষেত্রে সংখ্যা 18 বা তার বেশি হয় (ii) কোডটি প্রোফাইল হিসাবে দেওয়া হয় এটি চালানো হয় এবং প্রোফাইলার নির্ধারণ করে যে রানটাইমের সময় কোন পদ্ধতিটি আরও ভাল। আমি উত্তর খুঁজে পাচ্ছি না।
— assylias
3
30-কেস বিশৃঙ্খলা এবং 18-কেস এক দেখতে বেশিরভাগই একই রকম। পার্থক্যগুলি বেশিরভাগ 11 তম মামলার পরে অতিরিক্ত রেজিস্ট্রার বদলানোর ক্ষেত্রে সীমাবদ্ধ বলে মনে হয়। জেআইটার কেন তা করে বলতে পারে না; এটি অপ্রয়োজনীয় প্রদর্শিত হয়।
— সিএওও
46

স্যুইচ করুন - কেস মানগুলি একটি সংকীর্ণ পরিসরে ডিমের মধ্যে রাখলে কেস দ্রুত হয়। 

case 1:
case 2:
case 3:
..
..
case n:

কারণ, এই ক্ষেত্রে সংকলকটি স্যুইচ বিবৃতিতে প্রতিটি কেস লেগের জন্য তুলনা সম্পাদন করতে পারে। সংকলকটি একটি জাম্প টেবিল তৈরি করে যাতে বিভিন্ন পায়ে নেওয়া ক্রিয়াগুলির ঠিকানা থাকে। যে মানটির উপর স্যুইচটি করা হচ্ছে তা হ'ল এটির সূচকগুলিতে রূপান্তর করতে jump table। এই বাস্তবায়নে, স্যুইচ বিবৃতিতে নেওয়া সময়টি যদি অন্যথায়-যদি বিবৃতি ক্যাসকেডের সমতুল্য সময়ে নেওয়া সময়ের চেয়ে অনেক কম হয়। এছাড়াও স্যুইচ বিবৃতিতে নেওয়া সময়টি স্যুইচ বিবৃতিতে কেস পায়ের সংখ্যা থেকে পৃথক।

সংকলন বিভাগে স্যুইচ বিবৃতি সম্পর্কে উইকিপিডিয়ায় যেমন বলা হয়েছে ।

যদি ইনপুট মানগুলির ব্যাপ্তিটি সনাক্তকরণযোগ্যভাবে 'ছোট' হয় এবং কেবল কয়েকটি ফাঁক থাকে তবে কিছু সংকলক শর্ত সাপেক্ষে দীর্ঘতর সিরিজের পরিবর্তে একটি শাখা টেবিল বা সূচিযুক্ত ফাংশন পয়েন্টারগুলির একটি অ্যারে হিসাবে সুইচ বিবৃতিটি বাস্তবায়িত করতে পারে। এটি তুলনার তালিকায় না গিয়ে কোন শাখাটি কার্যকর করতে হবে তা তাত্ক্ষণিকভাবে নির্ধারণ করতে স্যুইচ বিবৃতিটিকে অনুমতি দেয়।

— বিশাল কে
সূত্র
4
এটা সঠিক নয় ক্ষেত্রে মানগুলি সংকীর্ণ বা প্রশস্ত আকারে নির্বিশেষে এটি দ্রুততর হবে। এটি ও (1) - কেস মানগুলি কতটা পৃথক তা বিবেচনা করা উচিত নয়।
— অনিকেত ইঞ্জে
6
@ অ্যানিকেট: উইকিপিডিয়া এই নিবন্ধটি পড়ুন। en.wikedia.org/wiki/Branch_table
— বিশাল কে
14
@ অ্যানিকেট: ব্যাপ্তি প্রশস্ত এবং অপ্রয়োজনীয় হলে এটি ও (1) নয় not এখানে দুটি ধরণের স্যুইচ রয়েছে এবং যদি পরিসীমাটি খুব বেশি ছড়িয়ে পড়ে তবে জাভা এটিকে "টেবিলসুইচ" এর পরিবর্তে "লুকসুচসুইচ" তে সংকলন করবে। প্রাক্তনটির প্রতিটি শাখায় একটি তুলনা প্রয়োজন তবে তার সন্ধান পাওয়া যায় না, যদিও এর পরে নেই।
— সিএওও
4
তথ্যসূত্র খুঁজতে উইকিপিডিয়া একটি শালীন জায়গা, তবে এটি একটি অনুমোদনযোগ্য উত্স হিসাবে বিবেচনা করা উচিত নয়। আপনি সেখানে যা কিছু পড়েন তা সেকেন্ড হ্যান্ড ইনফরমেশন।
— সিএওও
6
@ অ্যানিকেট: সমস্ত ন্যায্যতার মধ্যে, বিচ্ছিন্নতা একটি নির্দিষ্ট প্ল্যাটফর্মের প্রদত্ত জেভিএমের সাথে সুনির্দিষ্ট। অন্যরা এটি অন্যভাবে অনুবাদ করতে পারে। কিছু সম্ভবত লুকসুইচ জন্য একটি হ্যাশ টেবিল ব্যবহার করতে পারে। এটি এখনও একটি টেবিলসুইচ পাশাপাশি সঞ্চালন করবে না, তবে এটি কমপক্ষে কাছাকাছি হতে পারে। এটি জেআইটি-তে আরও বেশি সময় নিতে পারে এবং ইনপুটটিতে একটি হ্যাশিং অ্যালগরিদম প্রয়োগ করা জড়িত। সুতরাং যদিও ফলস্বরূপ অ্যাসেম্বলি কোডটি আলোকিত করা যেতে পারে, তবে এটি অনুমোদিত নয় তবে আপনি উইন্ডোজ x86_64- তে হটস্পট ভি 1.7 সম্পর্কে যেভাবে কথা বলছেন না unless
— সিএইচও
30

উত্তরটি বাইটকোডে রয়েছে:

SwitchTest10.java

public class SwitchTest10 {

    public static void main(String[] args) {
        int n = 0;

        switcher(n);
    }

    public static void switcher(int n) {
        switch(n) {
            case 0: System.out.println(0);
                    break;

            case 1: System.out.println(1);
                    break;

            case 2: System.out.println(2);
                    break;

            case 3: System.out.println(3);
                    break;

            case 4: System.out.println(4);
                    break;

            case 5: System.out.println(5);
                    break;

            case 6: System.out.println(6);
                    break;

            case 7: System.out.println(7);
                    break;

            case 8: System.out.println(8);
                    break;

            case 9: System.out.println(9);
                    break;

            case 10: System.out.println(10);
                    break;

            default: System.out.println("test");
        }
    }       
}

সংশ্লিষ্ট বাইটকোড; শুধুমাত্র প্রাসঙ্গিক অংশ প্রদর্শিত:

public static void switcher(int);
  Code:
   0:   iload_0
   1:   tableswitch{ //0 to 10
        0: 60;
        1: 70;
        2: 80;
        3: 90;
        4: 100;
        5: 110;
        6: 120;
        7: 131;
        8: 142;
        9: 153;
        10: 164;
        default: 175 }

SwitchTest22.java:

public class SwitchTest22 {

    public static void main(String[] args) {
        int n = 0;

        switcher(n);
    }

    public static void switcher(int n) {
        switch(n) {
            case 0: System.out.println(0);
                    break;

            case 1: System.out.println(1);
                    break;

            case 2: System.out.println(2);
                    break;

            case 3: System.out.println(3);
                    break;

            case 4: System.out.println(4);
                    break;

            case 5: System.out.println(5);
                    break;

            case 6: System.out.println(6);
                    break;

            case 7: System.out.println(7);
                    break;

            case 8: System.out.println(8);
                    break;

            case 9: System.out.println(9);
                    break;

            case 100: System.out.println(10);
                    break;

            case 110: System.out.println(10);
                    break;
            case 120: System.out.println(10);
                    break;
            case 130: System.out.println(10);
                    break;
            case 140: System.out.println(10);
                    break;
            case 150: System.out.println(10);
                    break;
            case 160: System.out.println(10);
                    break;
            case 170: System.out.println(10);
                    break;
            case 180: System.out.println(10);
                    break;
            case 190: System.out.println(10);
                    break;
            case 200: System.out.println(10);
                    break;
            case 210: System.out.println(10);
                    break;

            case 220: System.out.println(10);
                    break;

            default: System.out.println("test");
        }
    }       
}

সংশ্লিষ্ট বাইটকোড; আবার কেবল প্রাসঙ্গিক অংশ দেখানো হয়েছে:

public static void switcher(int);
  Code:
   0:   iload_0
   1:   lookupswitch{ //23
        0: 196;
        1: 206;
        2: 216;
        3: 226;
        4: 236;
        5: 246;
        6: 256;
        7: 267;
        8: 278;
        9: 289;
        100: 300;
        110: 311;
        120: 322;
        130: 333;
        140: 344;
        150: 355;
        160: 366;
        170: 377;
        180: 388;
        190: 399;
        200: 410;
        210: 421;
        220: 432;
        default: 443 }

প্রথম ক্ষেত্রে, সংকীর্ণ পরিসীমা সহ, সংকলিত বাইটকোড একটি ব্যবহার করে tableswitch । দ্বিতীয় ক্ষেত্রে, সংকলিত বাইটকোড একটি ব্যবহার করে lookupswitch।

ভিতরে tableswitch , স্ট্যাকের শীর্ষে পূর্ণসংখ্যা মানটি শাখা / লাফের লক্ষ্য সন্ধানের জন্য, সারণিতে সূচীকরণ করতে ব্যবহৃত হয়। এই ঝাঁপ / শাখাটি তাত্ক্ষণিকভাবে সঞ্চালিত হয়। অতএব, এটি একটি O(1)অপারেশন।

এ lookupswitchআরও জটিল। এই ক্ষেত্রে, সঠিক কীটি না পাওয়া অবধি টেবিলে থাকা সমস্ত কীগুলির সাথে পূর্ণসংখ্যার মানটির তুলনা করা দরকার। কীটি সন্ধানের পরে, শাখা / জাম্প লক্ষ্য (যে এই কীটি ম্যাপ করা আছে) জাম্পের জন্য ব্যবহৃত হয়। যে সারণীতে ব্যবহৃত হয় lookupswitchতা বাছাই করা হয় এবং সঠিক কীটি খুঁজতে বাইনারি-অনুসন্ধান অ্যালগরিদম ব্যবহার করা যেতে পারে। বাইনারি অনুসন্ধানের জন্য পারফরম্যান্স O(log n)এবং পুরো প্রক্রিয়াটিও রয়েছে O(log n), কারণ লাফ দেওয়া এখনও রয়েছে O(1)। সুতরাং বিচ্ছিন্ন পরিসরের ক্ষেত্রে পারফরম্যান্স কম হওয়ার কারণটি হ'ল প্রথমে সঠিক কীটি দেখা উচিত কারণ আপনি সরাসরি টেবিলের সাথে সূচক করতে পারবেন না।

যদি খুব কম বিস্তৃত মান থাকে এবং আপনার কেবলমাত্র tableswitchব্যবহার করতে হয়, টেবিলটিতে মূলত ডামি এন্ট্রি থাকবে যা defaultবিকল্পটি নির্দেশ করে । উদাহরণস্বরূপ, অভিমানী যে গত এন্ট্রিতে SwitchTest10.javaছিল 21পরিবর্তে 10, আপনি পাবেন:

public static void switcher(int);
  Code:
   0:   iload_0
   1:   tableswitch{ //0 to 21
        0: 104;
        1: 114;
        2: 124;
        3: 134;
        4: 144;
        5: 154;
        6: 164;
        7: 175;
        8: 186;
        9: 197;
        10: 219;
        11: 219;
        12: 219;
        13: 219;
        14: 219;
        15: 219;
        16: 219;
        17: 219;
        18: 219;
        19: 219;
        20: 219;
        21: 208;
        default: 219 }

সুতরাং সংকলকটি মূলত ফাঁকের মধ্যে ডামি এন্ট্রিযুক্ত এই বিশাল টেবিলটি তৈরি করে, defaultনির্দেশের শাখার লক্ষ্যকে নির্দেশ করে। এমনকি যদি এটি না defaultথাকে তবে এটিতে স্যুইচ ব্লকের পরে নির্দেশের দিকে নির্দেশিত এন্ট্রি থাকবে । আমি কিছু বেসিক পরীক্ষা করেছি এবং আমি দেখতে পেয়েছি যে শেষ সূচী এবং পূর্ববর্তী একটি ( 9) এর মধ্যে ব্যবধান যদি এর চেয়ে বেশি হয় তবে 35এটি একটি এর lookupswitchপরিবর্তে একটি ব্যবহার করে tableswitch।

switchবিবৃতিটির আচরণ জাভা ভার্চুয়াল মেশিন স্পেসিফিকেশন (.3.10) এ সংজ্ঞায়িত করা হয়েছে :

যেখানে স্যুইচগুলির কেসগুলি অল্প হয় সেখানে টেবিলসুইচ নির্দেশের টেবিলের প্রতিনিধিত্ব স্থানের ক্ষেত্রে অদক্ষ হয়ে যায়। পরিবর্তে লুকসুইচ নির্দেশাবলী ব্যবহার করা যেতে পারে। সারণিতে লক্ষ্যবস্তু অফসেটের সাথে লুকসুইচ নির্দেশিকা নির্দেশ কী (কেস লেবেলের মান) জোড় করে। যখন একটি লুকসুইচ নির্দেশ কার্যকর করা হয়, স্যুইচটির এক্সপ্রেশনটির মানটি টেবিলের কীগুলির সাথে তুলনা করা হয়। কীগুলির মধ্যে একটি যদি অভিব্যক্তির মানের সাথে মিলে যায় তবে সম্পর্কিত লক্ষ্য অফসেটে কার্যকর করা চালিয়ে যায়। কোনও কী মিলছে না, ডিফল্ট টার্গেটে কার্যকর করা চলতে থাকে। [...]

— ভিভিন পালিথ
সূত্র
1
আমি প্রশ্নটি থেকে বুঝতে পারি যে সংখ্যাগুলি সর্বদা সংগত হয় তবে পরিসরটি কমবেশি দীর্ঘ হয় - উদাহরণস্বরূপ ক্ষেত্রে উদাহরণগুলি 0 থেকে 5 পর্যন্ত চলে যায় অন্য উদাহরণে তারা 0 থেকে 30 এ চলে যায় - এবং উদাহরণগুলির মধ্যে কোনওটিই বিচ্ছিন্ন মান ব্যবহার করে না
— অ্যাসিলিয়াস
পছন্দ করুন আমার ধারণা আমি প্রশ্নটি ভুল বুঝেছি। আমাকে আরও কিছু পরীক্ষা-নিরীক্ষা করি। সুতরাং আপনি বলছেন যে 0-30 থেকেও একটি সুসংগত ব্যাপ্তি সহ , সংকলকটি একটি ব্যবহার করে lookupswitch?
— ভিভিন পালিথ
@ ভিভিনপালিথ: হ্যাঁ, আমার পরীক্ষাগুলিতে কেস ধ্রুবক সর্বদা সংবেদনশীল থাকে, তাই আমি মূলত [0, 1], [0, 1, 2], [0, 1, 2, 3] ... ইত্যাদিতে সুইচগুলি পরীক্ষা করে যাচ্ছি
— অ্যান্ড্রু বিসেল
@ ভিভিনপালিথ না, বাইটোকোড সর্বদা একটি টেবিলসুইচ ব্যবহার করে - তবে জেআইটি সংকলকটি কতটা আইটেম রয়েছে তার উপর নির্ভর করে টেবিল সুইচকে সমাবেশে একইভাবে সংকলন করে না বলে মনে হয়।
— assylias
6
@ ভিভনপালিথ আমি এই প্রশ্নটি আরও স্পষ্টভাবে নিশ্চিত করে বলতে পারি। এই নিম্ন-স্তরের বাইটকোড এবং সমাবেশের জিনিসগুলির সাথে জড়িত উত্তরগুলির মূল্যায়ন করার সময় আমি আমার গভীরতার বাইরে চলে যাই। এটি এখনও আমার কাছে টেবিলসুইচ / লুকসুইচবিচের পার্থক্যটি বাস্তবে গুরুত্বপূর্ণ বলে মনে হয় এবং আপনার একমাত্র উত্তর যা এখনও পর্যন্ত এই পদগুলিকে নিয়োগ করে (যদিও অন্যরা সম্ভবত বিভিন্ন পরিভাষা দিয়ে একই ধারণাটি স্থাপন করছেন)। প্লাস আমি জেভিএম স্পেক্ট লিঙ্কটিও পছন্দ করি।
— অ্যান্ড্রু বিসেল
19

যেহেতু প্রশ্নের উত্তর ইতিমধ্যে দেওয়া হয়েছে (কম বা কম), তাই এখানে কিছু টিপস দেওয়া হয়েছে। ব্যবহার

private static final double[] mul={1d, 10d...};
static double multiplyByPowerOfTen(final double d, final int exponent) {
      if (exponent<0 || exponent>=mul.length) throw new ParseException();//or just leave the IOOBE be
      return mul[exponent]*d;
}

এই কোডটিতে উল্লেখযোগ্যভাবে কম আইসি (নির্দেশাবলী ক্যাশে) ব্যবহার করা হয়েছে এবং সর্বদা ইনলাইন হবে। কোডটি গরম হলে অ্যারেটি L1 ডেটা ক্যাশে থাকবে। দেখার টেবিলটি প্রায় সবসময়ই একটি জয়। (উদাঃ মাইক্রোব্যাঙ্কমার্কে: ডি)

সম্পাদনা করুন: আপনি যদি পদ্ধতিটি উত্তপ্তভাবে অন্তর্ভুক্ত করতে চান তবে দ্রুতগামী পাথগুলি ন্যূনতমের চেয়ে throw new ParseException()কম হওয়া বা আলাদা স্ট্যাটিক পদ্ধতিতে সরিয়ে নিয়ে যেতে (তাই এগুলি ন্যূনতম হিসাবে সংক্ষিপ্ত করে তোলা) consider এটাইthrow new ParseException("Unhandled power of ten " + power, 0); হ'ল একটি দুর্বল ধারণা / সি এটি কোডের জন্য অনেকগুলি ইনলাইনিং বাজেট খায় যা কেবল ব্যাখ্যা করা যায় - স্ট্রিং কনটেনটেশন বাইটকোডে বেশ ভার্জোজ। আরও তথ্য এবং একটি বাস্তব কেস ডাব্লু / অ্যারেলিস্ট

— bestsss
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.