การใช้ malloc ใน PIC

ฉันจะใช้malloc()และfree()ฟังก์ชั่นใน PIC ได้อย่างไร? ฉันตรวจสอบstdlib.hส่วนหัวแล้วและไม่มีการกล่าวถึงเลย ฉันใช้ MCC18

มีใครต้องใช้พวกเขา?

ฉันต้องการพวกเขาเพราะฉันกำลังย้ายห้องสมุดจาก Windows XP ไปยัง PIC คู่มือการย้ายระบบบอกว่า

ปรับฟังก์ชั่นเฉพาะของระบบปฏิบัติการให้เข้ากับ PIC ของฉัน

แต่ฉันไม่รู้วิธี "แปล" malloc()และfree()ฟังก์ชั่น

ในหลาย ๆ แอปพลิเคชั่นหนึ่งจะต้องจัดสรรหน่วยความจำ แต่ไม่จำเป็นต้องว่างอะไรในขณะที่รักษาบางสิ่งที่ถูกจัดสรรไว้หลังจากนั้น ในระบบดังกล่าวสิ่งที่ผู้ใช้ต้องทำคือใช้ตัวเชื่อมโยงเพื่อกำหนดอาร์เรย์โดยใช้ RAM ที่มีอยู่ทั้งหมดตั้งค่าตัวชี้ไปที่จุดเริ่มต้นของอาร์เรย์นั้นจากนั้นใช้ฟังก์ชัน malloc ง่าย ๆ ที่ดี:

ถ่าน * next_alloc;
เป็นโมฆะ * malloc (ขนาด int)
{
    ถ่าน * this_alloc;
    this_alloc = next_alloc;
    ถ้า ((END_OF_ALLOC_SPACE - this_alloc) <ขนาด)
      กลับ -1;
    next_alloc + = ขนาด;
    กลับ this_alloc;
}
เป็นโมฆะฟรี (เป็นโมฆะ * ptr)
{
    ถ้า (ptr)
        next_alloc = (ถ่าน *) ptr;
}

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

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

malloc()ในไมโครคอนโทรลเลอร์โดยทั่วไปถือว่าเป็น "สิ่งเลวร้าย" แต่ถ้าคุณต้องการมันอย่างแน่นอนคุณจะต้องหาบุคคลที่สาม

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

ฉันเคยใช้วิธีการนี้มาก่อนในการย้ายพอร์ตไลบรารีพีซีไปยังไมโครคอนโทรลเลอร์

ด้านล่างนี้คุณควรที่จะติดตั้งที่มีการจัดสรรและการจัดสรรหน่วยความจำmy_malloc_init() มีไว้เพื่อตอบสนองการพึ่งพา แต่จะไม่ทำอะไรเลย ในที่สุดคุณก็จะหมดพื้นที่แน่นอนmy_malloc()my_free()

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

uint8_t heap[HEAP_SIZE];
uint8_t *heap_ptr;

void my_malloc_init(void)
{
    heap_ptr = heap;
}

void *my_malloc(size_t len)
{
    uint8_t *p = heap_ptr;
    heap_ptr += len;
    if (heap_ptr >= heap + HEAP_SIZE)
        return NULL;
    else
        return p;
}

void my_free(void)
{
    // do nothing
}

(หมายเหตุ: ในโลกแห่งความเป็นจริงคุณอาจต้องพิจารณาการจัดตำแหน่งตัวชี้เช่นการปัดเศษขึ้นheap_ptr2 หรือ 4 ไบต์)

อีกทางเลือกหนึ่งคือการใช้โครงสร้างการจัดสรรที่ง่ายกว่าmalloc()ปกติที่มีให้เช่น FreeListถึงแม้ว่าสิ่งนี้อาจไม่อนุญาตให้คุณจัดสรรบล็อกขนาดตัวแปร

นี่คือคำตอบสำหรับคำถามของคุณแทบจะไม่ แต่การจัดสรรหน่วยความจำแบบไดนามิกมักจะเกิดขึ้นกับสภาพแวดล้อม RAM ขนาดเล็กและในกรณีที่ไม่มีระบบปฏิบัติการ (เช่นในโลกของไมโครคอนโทรลเลอร์) ... พื้นที่ฮีปที่คุณมีในสภาพแวดล้อมแบบฝังตัว วัดเป็นร้อยไบต์ ...

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

ฉันไม่ทราบว่าไลบรารี่มาตรฐาน C18 รองรับmallocหรือfreeไม่ แต่Microchip App Note AN914จะแสดงวิธีการใช้งานของคุณเอง

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

หากสิ่งที่คุณทำมีการกำหนดแบบไดนามิกอย่างแท้จริงในเวลาทำงาน (หายากสำหรับสิ่งที่ฝังตัวส่วนใหญ่) และคุณจะต้องจัดสรรพื้นที่ในโอกาสพิเศษสองสามครั้งฉันสามารถเห็นmallocและfreeยอมรับได้

PIC ของคุณมีขนาดเท่าไหร่ในแง่ของหน่วยความจำ?

malloc เป็นมากวิธีที่ไม่มีประสิทธิภาพของหน่วยความจำที่จัดสรร ปัญหาก็คือหน่วยความจำสามารถแยกส่วนกับ frees และ mallocs บ่อยและมีหน่วยความจำเพียงไม่กี่กิโลไบต์ความล้มเหลวในการจัดสรรเป็นเรื่องธรรมดาเกินไป อาจเป็นไปได้ว่าถ้าคุณใช้ชิปขนาดเล็กกว่าหรือ PIC18 รุ่นก่อนหน้านี้ไม่มีการรองรับ malloc เนื่องจาก Microchip มองว่ามันยากที่จะติดตั้ง (หรืออาจเป็นไปไม่ได้ในบางกรณี) หรือไม่เพียงพอสำหรับการใช้งาน คุ้มค่า ไม่ต้องพูดถึง แต่ก็ค่อนข้างช้าคุณมองไปที่ 1 รอบเพื่อใช้บัฟเฟอร์แบบคงที่ที่มีอยู่แล้วและ 100 ถึง 1,000 รอบของการทำ malloc

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

และหากคุณกำลังพัฒนา / ย้ายพอร์ต "ระบบปฏิบัติการ" บน PIC18 และหากรองรับไมโครคอนโทรลเลอร์ก็อาจมีการรองรับการจัดสรรแบบคงที่ ตัวอย่างเช่น SQLite3 รองรับการจัดสรรแบบคงที่ - คุณจัดสรรอาร์เรย์บัฟเฟอร์ที่มีขนาดใหญ่และใช้สิ่งที่เป็นไปได้แม้ว่าจะไม่เหมาะสำหรับไมโครคอนโทรลเลอร์ ถ้าไม่เช่นนั้นคุณแน่ใจหรือไม่ว่ามันถูกออกแบบมาสำหรับ PIC18 ขนาดเล็ก?

หากคุณกำลังพิจารณาmalloc()และfree()ซอฟต์แวร์ฝังตัวของคุณผมขอแนะนำให้คุณลองดูที่ UC / OS-II และและOSMemGet() OSMemPut()ในขณะที่malloc()ให้คุณจัดสรรบล็อกหน่วยความจำโดยพลการOSMem*()ให้บล็อกขนาดคงที่จากพูลที่จัดสรรไว้ล่วงหน้า ฉันพบว่าวิธีนี้มีความสมดุลที่ดีระหว่างความยืดหยุ่นmalloc()และความทนทานของการจัดสรรแบบคงที่

AFAIK เพื่อทำสิ่งนี้อย่างถูกต้องคุณต้องมองอุปกรณ์ที่มีหน่วยความจำการจัดการ (MMU) ในขณะที่มีกลไกการจัดสรรแบบไดนามิกสำหรับซีรีย์ PIC18 นั้นมีอยู่จริงพวกเขาจะไม่เป็นแบบนั้น - และพูดในฐานะคนที่ทำงานกับเฟิร์มแวร์ที่ผลักดันขีด จำกัด ของซีรีย์ PIC18 ฉันสามารถพูดได้ว่า แอปพลิเคชั่นขนาดใหญ่ภายในนั้นหากคุณใช้โอเวอร์เฮดทั้งหมดในตัวจัดการหน่วยความจำ

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