วิธีบีบรหัสสำหรับ Flash และ RAM เพิ่มเติม [ปิด]

ฉันทำงานเกี่ยวกับการพัฒนาฟีเจอร์สำหรับผลิตภัณฑ์เฉพาะของเรา มีการร้องขอให้ย้ายฟีเจอร์เดียวกันไปยังผลิตภัณฑ์อื่น ผลิตภัณฑ์นี้ใช้ไมโครคอนโทรลเลอร์ M16C ซึ่งมี 64K Flash และ RAM 2k

มันเป็นผลิตภัณฑ์สำหรับผู้ใหญ่และดังนั้นจึงเหลือ 132 ไบต์ของแฟลชและเหลือ 2 ไบต์ของ RAM

ในการพอร์ตคุณสมบัติที่ร้องขอ (คุณสมบัติได้รับการปรับให้เหมาะสมแล้ว) ฉันต้องการ 1,400 ไบต์ของแฟลชและ RAM ขนาด 200 ~

ไม่มีใครมีข้อเสนอแนะใด ๆ เกี่ยวกับวิธีการดึงข้อมูลไบต์เหล่านี้ด้วยการกระชับโค้ด? ฉันจะมองหาสิ่งที่เฉพาะเจาะจงเมื่อฉันพยายามที่จะกระชับรหัสการทำงานที่มีอยู่แล้ว?

ความคิดใด ๆ ที่จะได้รับการชื่นชมจริงๆ

ขอบคุณ

คุณมีสองทางเลือก: อันดับแรกคือมองหารหัสที่ซ้ำซ้อนและย้ายไปที่สายเดียวเพื่อกำจัดการซ้ำซ้อน ประการที่สองคือการลบฟังก์ชั่น

ลองดูที่ไฟล์. map และดูว่ามีฟังก์ชั่นที่คุณสามารถกำจัดหรือเขียนซ้ำได้หรือไม่ ตรวจสอบให้แน่ใจว่าการเรียกใช้ไลบรารีที่จำเป็นต้องใช้จริง ๆ

สิ่งต่าง ๆ เช่นการหารและการคูณสามารถนำมาในรหัสจำนวนมาก แต่การใช้กะและการใช้ค่าคงที่ดีกว่าสามารถทำให้รหัสมีขนาดเล็กลง ดูสิ่งต่าง ๆ เช่นค่าคงที่สตริงและprintfs ตัวอย่างเช่นแต่ละคนprintfจะกินรอมของคุณ แต่คุณอาจมีสตริงรูปแบบที่ใช้ร่วมกันสองชุดแทนที่จะทำซ้ำค่าคงที่ของสตริงนั้นซ้ำแล้วซ้ำอีก

สำหรับหน่วยความจำดูว่าคุณสามารถกำจัดกลมและใช้รถยนต์ในฟังก์ชั่นแทน ยังหลีกเลี่ยงตัวแปรจำนวนมากในฟังก์ชั่นหลักที่เป็นไปได้เพราะสิ่งเหล่านี้กินหน่วยความจำเช่นเดียวกับ globals

มันคุ้มค่าที่จะดูการแสดงรายการไฟล์ (แอสเซมเบลอร์) เพื่อค้นหาสิ่งที่คอมไพเลอร์เฉพาะของคุณไม่ดีโดยเฉพาะ

ตัวอย่างเช่นคุณอาจพบว่าตัวแปรโลคัลมีราคาแพงมากและหากแอปพลิเคชันนั้นง่ายพอที่จะคุ้มค่ากับความเสี่ยงการย้ายลูปตัวนับสองสามตัวไปเป็นตัวแปรแบบสแตติกอาจบันทึกโค้ดจำนวนมาก

หรือการจัดทำดัชนีอาร์เรย์อาจมีราคาแพงมาก แต่การดำเนินการตัวชี้ถูกกว่ามาก หรือในทางกลับกัน

แต่การดูภาษาแอสเซมบลีเป็นขั้นตอนแรก

การปรับให้เหมาะสมของคอมไพเลอร์เช่น-Osใน GCC ให้ความสมดุลที่ดีที่สุดระหว่างความเร็วและขนาดโค้ด หลีกเลี่ยง-O3เนื่องจากอาจเพิ่มขนาดรหัส

สำหรับ RAM ให้ตรวจสอบช่วงของตัวแปรทั้งหมดของคุณ - คุณใช้ ints ซึ่งคุณสามารถใช้ถ่านได้หรือไม่? บัฟเฟอร์ใหญ่กว่าที่พวกเขาต้องการหรือไม่

การบีบอัดรหัสเป็นแอพพลิเคชั่นมากและขึ้นอยู่กับรูปแบบการเข้ารหัส จำนวนเงินที่เหลือของคุณแนะนำว่าอาจรหัสได้ผ่านไปแล้วแม้ว่าจะมีการบีบบางอย่างซึ่งอาจหมายความว่ามีเหลืออีกเล็กน้อย

ดูการใช้งานโดยรวม - มีบางอย่างที่ไม่ได้ใช้จริง ๆ และสามารถถูกโยนทิ้งได้หรือไม่?

หากเป็นโครงการเก่า แต่คอมไพเลอร์ได้รับการพัฒนาตั้งแต่นั้นอาจเป็นไปได้ว่าคอมไพเลอร์ล่าสุดอาจผลิตรหัสขนาดเล็กลง

การตรวจสอบคู่มือคอมไพเลอร์ของคุณเป็นสิ่งที่คุ้มค่าเสมอ

สำหรับ gcc -ffunction-sectionsและ-fdata-sectionsด้วยการ--gc-sectionsเชื่อมโยงธงเป็นสิ่งที่ดีสำหรับการปอกรหัสตาย

นี่คือเคล็ดลับที่ยอดเยี่ยมอื่น ๆ(มุ่งสู่ AVR)

คุณสามารถตรวจสอบจำนวนพื้นที่สแต็กและพื้นที่ฮีปที่จัดสรร คุณอาจได้รับ RAM เป็นจำนวนมากหากมีการจัดสรรอย่างใดอย่างหนึ่งหรือทั้งสองอย่าง

ฉันเดาสำหรับโครงการที่เหมาะสมใน 2k ของแรมจะเริ่มต้นด้วยไม่มีการจัดสรรหน่วยความจำแบบไดนามิก (ใช้malloc, callocฯลฯ ) หากเป็นกรณีนี้คุณสามารถกำจัดฮีปของคุณไปด้วยกันโดยสมมติว่าผู้เขียนต้นฉบับทิ้งแรมไว้บางส่วนสำหรับฮีป

คุณต้องระมัดระวังอย่างมากในการลดขนาดสแต็กเนื่องจากอาจทำให้เกิดข้อบกพร่องที่หาได้ยาก อาจเป็นประโยชน์ในการเริ่มต้นด้วยการเริ่มต้นพื้นที่สแต็กทั้งหมดให้เป็นค่าที่รู้จัก (สิ่งอื่นนอกเหนือจาก 0x00 หรือ 0xff เนื่องจากค่าเหล่านี้เกิดขึ้นโดยทั่วไปแล้ว) จากนั้นเรียกใช้ระบบในขณะที่ดูจำนวนสแตกพื้นที่ที่ไม่ได้ใช้

รหัสของคุณใช้เลขทศนิยมหรือไม่? คุณสามารถนำอัลกอริทึมของคุณกลับมาใช้ใหม่ได้โดยใช้เลขจำนวนเต็มเท่านั้นและกำจัดค่าโสหุ้ยในการใช้ไลบรารี C floating point เช่นในบางแอปพลิเคชันฟังก์ชันเช่น sine, log, exp สามารถถูกแทนที่ด้วยการประมาณพหุนามจำนวนเต็ม

รหัสของคุณใช้ตารางค้นหาขนาดใหญ่สำหรับอัลกอริทึมใด ๆ เช่นการคำนวณ CRC หรือไม่ คุณสามารถลองแทนที่อัลกอริทึมรุ่นอื่นที่คำนวณค่าได้ทันทีแทนที่จะใช้ตารางค้นหา ข้อแม้คืออัลกอริธึมที่เล็กกว่านั้นช้ากว่าดังนั้นโปรดตรวจสอบให้แน่ใจว่าคุณมีรอบการทำงานของ CPU ที่เพียงพอ

รหัสของคุณมีข้อมูลคงที่จำนวนมากเช่นตารางสตริงหน้า HTML หรือกราฟิกพิกเซล (ไอคอน) หรือไม่ ถ้ามันมีขนาดใหญ่พอ (พูดถึง 10 kB) มันอาจคุ้มค่าที่จะใช้รูปแบบการบีบอัดที่ง่ายมากเพื่อลดขนาดของข้อมูลและขยายขนาดเมื่อจำเป็น

คุณสามารถลองจัดเรียงรหัสใหม่ให้มีขนาดกะทัดรัดขึ้น มันขึ้นอยู่กับว่าโค้ดกำลังทำอะไรอยู่มากมาย กุญแจสำคัญคือการค้นหาสิ่งที่คล้ายกันและนำไปใช้ใหม่ในแง่ของกันและกัน สุดขีดจะใช้ภาษาระดับที่สูงขึ้นเช่น Forth ซึ่งจะง่ายต่อการบรรลุความหนาแน่นของรหัสที่สูงกว่าใน C หรือแอสเซมเบลอร์

นี่คือForth สำหรับ M16C

ตั้งค่าระดับการปรับให้เหมาะสมของคอมไพเลอร์ IDE หลายตัวมีการตั้งค่าที่อนุญาตให้ปรับขนาดโค้ดได้โดยเสียเวลารวบรวม (หรืออาจใช้เวลาประมวลผลในบางกรณี) พวกเขาสามารถทำให้การบีบอัดโค้ดทำได้โดยใช้เครื่องมือเพิ่มประสิทธิภาพของพวกเขาสองครั้งค้นหารูปแบบที่สามารถเพิ่มประสิทธิภาพที่พบได้น้อยลงและเทคนิคอื่น ๆ อีกมากมายที่อาจไม่จำเป็นสำหรับการคอมไพล์แคช / ดีบัก โดยปกติแล้วคอมไพเลอร์จะถูกตั้งค่าให้อยู่ในระดับที่เหมาะสมของการเพิ่มประสิทธิภาพ ขุดรอบในการตั้งค่าที่คุณควรจะสามารถหาระดับการเพิ่มประสิทธิภาพตามจำนวนเต็ม

หากคุณใช้คอมไพเลอร์ระดับมืออาชีพเช่น IAR อยู่แล้วฉันคิดว่าคุณจะต้องดิ้นรนเพื่อให้เกิดการประหยัดอย่างจริงจังด้วยการปรับแต่งโค้ดระดับล่างเล็กน้อย - คุณจะต้องมองหาวิธีกำจัดฟังก์ชั่นหรือทำเรื่องสำคัญ ๆ เขียนชิ้นส่วนใหม่อย่างมีประสิทธิภาพมากขึ้น คุณจะต้องเป็น coder ที่ฉลาดกว่าใครก็ตามที่เขียนเวอร์ชันดั้งเดิม ... สำหรับ RAM คุณต้องดูอย่างจริงจังว่ามันใช้งานอย่างไรในปัจจุบันและดูว่ามีขอบเขตสำหรับการใช้งาน RAM ซ้อนทับกันหรือไม่สำหรับ สิ่งต่าง ๆ ในเวลาต่าง ๆ (สหภาพมีประโยชน์สำหรับเรื่องนี้) ฮีปและขนาดสแต็คเริ่มต้นของ IAR ใน ARM / AVR ที่ฉันมีแนวโน้มจะใจกว้างเกินไปดังนั้นสิ่งเหล่านี้จะเป็นสิ่งแรกที่ต้องพิจารณา

อย่างอื่นในการตรวจสอบ - คอมไพเลอร์บางอย่างเกี่ยวกับสถาปัตยกรรมบางคัดลอกคงแรม - โดยปกติจะใช้เมื่อมีการเข้าถึงการคงแฟลชช้า / ยาก (เช่น AVR) เช่น IAR ของ AVR คอมไพเลอร์ต้องมี _ _flash qualifer จะไม่คัดลอกอย่างต่อเนื่องเพื่อแรม)

หากตัวประมวลผลของคุณไม่ได้รับการสนับสนุนฮาร์ดแวร์สำหรับพารามิเตอร์ / สแต็กท้องถิ่น แต่คอมไพเลอร์พยายามที่จะใช้กองซ้อนพารามิเตอร์ทำงานอยู่แล้วและถ้ารหัสของคุณไม่จำเป็นต้องเข้าใหม่คุณอาจจะสามารถบันทึกรหัส พื้นที่โดยการจัดสรรตัวแปรอัตโนมัติแบบคงที่ ในบางกรณีต้องดำเนินการด้วยตนเอง ในกรณีอื่น ๆ คำสั่งคอมไพเลอร์สามารถทำได้ การจัดสรรด้วยตนเองที่มีประสิทธิภาพจะต้องมีการแชร์ตัวแปรระหว่างรูทีน การแชร์ดังกล่าวจะต้องทำอย่างระมัดระวังเพื่อให้แน่ใจว่าไม่มีรูทีนใช้ตัวแปรที่รูทีนอื่นพิจารณาว่าเป็น "อยู่ในขอบเขต" แต่ในบางกรณีผลประโยชน์ที่มีขนาดรหัสอาจมีความสำคัญ

โปรเซสเซอร์บางตัวมีการเรียกประชุมที่อาจทำให้รูปแบบการส่งพารามิเตอร์บางอย่างมีประสิทธิภาพมากกว่าคนอื่น ๆ ตัวอย่างเช่นในคอนโทรลเลอร์ PIC18 หากรูทีนใช้พารามิเตอร์ one-byte เดียวมันอาจถูกส่งผ่านในรีจิสเตอร์ หากใช้มากกว่านั้นพารามิเตอร์ทั้งหมดจะต้องถูกส่งผ่านใน RAM หากรูทีนจะใช้พารามิเตอร์หนึ่งไบต์สองพารามิเตอร์อาจมีประสิทธิภาพมากที่สุดในการ "ผ่าน" หนึ่งในตัวแปรส่วนกลางแล้วส่งผ่านพารามิเตอร์อื่นเป็นพารามิเตอร์ ด้วยกิจวัตรที่ใช้กันอย่างแพร่หลายการประหยัดสามารถเพิ่มขึ้น อาจมีความสำคัญอย่างยิ่งหากพารามิเตอร์ที่ส่งผ่าน global เป็นแฟล็กบิตเดียวหรือหากโดยปกติจะมีค่าเป็น 0 หรือ 255 (เนื่องจากมีคำแนะนำพิเศษในการจัดเก็บ 0 หรือ 255 ไว้ใน RAM)

บน ARM การวางตัวแปรส่วนกลางที่ใช้บ่อยในโครงสร้างอาจลดขนาดรหัสอย่างมีนัยสำคัญและปรับปรุงประสิทธิภาพ ถ้า A, B, C, D และ E เป็นตัวแปรส่วนกลางที่แยกกันดังนั้นรหัสที่ใช้ทั้งหมดจะต้องโหลดที่อยู่ของแต่ละรายการลงในการลงทะเบียน หากมีการลงทะเบียนไม่เพียงพออาจจำเป็นต้องโหลดที่อยู่เหล่านั้นซ้ำหลายครั้ง ในทางตรงกันข้ามหากพวกเขาเป็นส่วนหนึ่งของโครงสร้างทั่วโลกเดียวกัน MyStuff แล้วรหัสที่ใช้ MyStuff.A, MyStuff.B ฯลฯ สามารถโหลดที่อยู่ของ MyStuff เพียงครั้งเดียว ชนะครั้งใหญ่

1. หากรหัสของคุณต้องอาศัยโครงสร้างจำนวนมากตรวจสอบให้แน่ใจว่าสมาชิกโครงสร้างได้รับคำสั่งจากหน่วยความจำส่วนใหญ่ให้น้อยที่สุด

ตัวอย่าง: "uint32_t uint16_t uint8_t" แทน "uint16_t uint8_t uint32_t"

สิ่งนี้จะช่วยให้มั่นใจว่าโครงสร้างขั้นต่ำ

2. ใช้ const สำหรับตัวแปรที่เกี่ยวข้อง เพื่อให้มั่นใจว่าตัวแปรเหล่านั้นจะอยู่ใน ROM และไม่กิน RAM

เทคนิคเล็กน้อย (อาจชัดเจน) ที่ฉันใช้ประสบความสำเร็จในการบีบอัดรหัสลูกค้าบางส่วน:

1. กระชับแฟล็กลงในฟิลด์บิตหรือบิตมาสก์ สิ่งนี้อาจเป็นประโยชน์เพราะโดยปกติแล้ว booleans จะถูกเก็บเป็นจำนวนเต็มดังนั้นการสูญเสียความทรงจำ สิ่งนี้จะบันทึกทั้งแรมและ ROM และคอมไพเลอร์มักไม่ได้ทำ

2. ค้นหาความซ้ำซ้อนในรหัสและใช้ลูปหรือฟังก์ชั่นเพื่อดำเนินการคำสั่งซ้ำ

3. ฉันยังบันทึก ROM บางส่วนโดยแทนที่if(x==enum_entry) <assignment>คำสั่งจำนวนมากจากค่าคงที่ด้วยอาร์เรย์ที่จัดทำดัชนีโดยดูแลว่ารายการ enum สามารถใช้เป็นดัชนีอาร์เรย์ได้

หากทำได้ให้ใช้ฟังก์ชั่นอินไลน์หรือมาโครคอมไพเลอร์แทนฟังก์ชั่นเล็ก ๆ มีค่าใช้จ่ายขนาดและความเร็วด้วยการส่งผ่านข้อโต้แย้งและสามารถแก้ไขได้โดยการทำให้ฟังก์ชั่นอินไลน์

เปลี่ยนตัวแปรโลคัลให้มีขนาดเท่ากันกับ CPU ของคุณ

หาก CPU เป็น 32 บิตให้ใช้ตัวแปร 32 บิตแม้ว่าค่าสูงสุดจะไม่ได้รับเกิน 255 ผมใช้ตัวแปร 8 บิตคอมไพเลอร์จะเพิ่มรหัสเพื่อปกปิดรหัส 24 บิตด้านบน

ที่แรกที่ฉันจะดูคือตัวแปร for-loop

for( i = 0; i < 100; i++ )

นี่อาจดูเหมือนเป็นสถานที่ที่ดีสำหรับตัวแปร 8 บิต แต่ตัวแปร 32 บิตอาจสร้างโค้ดน้อยลง