🎠 🕵🏻 🐶 ओपनएमसीएपीआई: मल्टी-कोर प्रोसेसर पर लिनक्स और आरटीओएस को एक साथ चलाना 🤥 📺 😍

रोजमर्रा के अभ्यास में, एम्बेडेड सिस्टम के डेवलपर को एक चिप पर एन-कोर सिस्टम पर दो या अधिक विविध ओएस चलाने की आवश्यकता से निपटना पड़ता है। यह आमतौर पर लिनक्स और विशिष्ट आरटीओएस है। Linux के कंधे पर हेवीवेट प्रोटोकॉल स्टैक हैं, जबकि RTOS वास्तविक समय के कार्यों को संभालता है।

सिस्टम के इस तरह के संगठन के साथ उत्पन्न होने वाले मुख्य कार्यों में से एक बातचीत के लिए एक तंत्र प्रदान करना है, अर्थात् आंतरिक परमाणु विनिमय। यदि आप OpenMCAPI ओपन लाइब्रेरी पर आधारित किसी एक समाधान को सीखने में रुचि रखते हैं, तो प्रोग्राम कोड की दर्जनों लाइनों की एक जोड़ी के माध्यम से फ़्लिप करते हैं और इस लाइब्रेरी का उपयोग करते समय वास्तविक थ्रूपुट संख्याएं देखते हैं, बिल्ली का स्वागत है।

आंतरिक मेमोरी एक्सचेंज का कार्य साझा मेमोरी का उपयोग करके सफलतापूर्वक हल किया जाता है और इंटरेक्शन की अपनी परत लिखने और इसे विभिन्न ऑपरेटिंग सिस्टमों में पोर्ट करने के साथ इंटर्नल न्यूक्लियर का उपयोग करता है। इस API को मानकीकृत रूप में लाने के लिए, मल्टीकोर एसोसिएशन (MCA) ने MCAPI (मल्टीकोर कम्युनिकेशंस एपीआई) विनिर्देश के पहले संस्करण को विकसित और जारी किया, और जल्द ही दूसरा संस्करण जारी किया गया।

प्रश्न में ओपनएमसीएपीआई पुस्तकालय एमसीएपीआई 2.0 विनिर्देश पर आधारित है, जिसे मेंटर ग्राफिक्स कॉर्पोरेशन द्वारा विकसित किया गया है और यह मुक्त बीएसडी / जीपीएल लाइसेंस के तहत खुला स्रोत है। स्रोत कोड परियोजना की वेबसाइट का उपयोग करके प्राप्त किया जा सकता है, लॉन्च और पोर्टिंग की एक संक्षिप्त जानकारी भी है।

OpenMCAPI लाइब्रेरी शुरू में वर्चुअल ट्रांसपोर्ट या शेयर्ड मेमोरी (लेकिन केवल mpc85xx और mv78xx0 प्लेटफॉर्म पर) का उपयोग करके लिनक्स के तहत काम करने की क्षमता प्रदान करती है।

ओपनएमसीएपीआई के माध्यम से लिनक्स और आरटीओएस की बातचीत की प्रस्तावित संरचना को अमूर्त स्तरों में अलग करने के लिए निम्नानुसार है (चित्र 1 देखें):

चित्रा। 1. ओपनएमसीएपीआई के माध्यम से लिनक्स और आरटीओएस की बातचीत की संरचना

लिनक्स के लिए पोर्ट सोर्स कोड के उदाहरणों के साथ उपरोक्त संरचना के कार्यान्वयन पर विचार करें:

MCAPI जेनेरिक बाह्य MCAPI API का कार्यान्वयन है।
OS लेयर जेनेरिक MCAPI लेयर का हिस्सा है, जिसमें ऑपरेटिंग सिस्टम-विशिष्ट कोड होता है। यह भाग फ़ाइल में प्रस्तुत किया गया है libmcapi / mcapi / linux / mcapi_os.c और इसमें कार्यान्वयन शामिल है:
ट्रांसपोर्ट जेनेरिक एक अमूर्त परत है जो यूजर स्पेस स्तर पर साझा मेमोरी के साथ काम करने के लिए एक तंत्र प्रदान करता है। यह libmcapi / shm / shm.c और libmcapi / shm / linux / shm_os.c फाइलों द्वारा दर्शाया गया है और इसमें एक कार्यान्वयन शामिल है:
ओएस स्पेसिफिक ड्राइवर को लिनक्स कर्नेल मॉड्यूल द्वारा पेश किया जाता है, जो उपयोगकर्ता स्थान से उपकरणों तक सीधी पहुंच प्रदान करता है। मॉड्यूल libmcapi / shm / linux / kmod फ़ोल्डर में स्थित है और इसमें कार्यान्वयन शामिल है:

साझा मेमोरी का उपयोग करते हुए परिवहन के माध्यम से बातचीत के तंत्र की पूरी समझ के लिए, जिसे ओपनएमसीएपीआई पुस्तकालय में लागू किया गया है, आंतरिक मेमोरी तंत्र और साझा मेमोरी में डेटा संरचना पर विचार करना आवश्यक है।

आगे का विचार mpc85xx प्लेटफॉर्म ( फ्रीस्केल के P1020 चिप ) पर आधारित होगा। सॉफ्टवेयर: पैच के साथ लिनक्स कर्नेल संस्करण 2.6.35, जो कि फ्रीस्केल QorIQ_SDK_V1_03 विकास किट (एसडीके) (उनकी वेबसाइट पर पंजीकरण के बाद उपलब्ध है) के साथ आता है, RTEMS का उपयोग वास्तविक समय ऑपरेटिंग सिस्टम (RTOS) के रूप में किया जाता है, जिसका स्रोत कोड हो सकता है git पर git रिपॉजिटरी को प्राप्त करें: //git.rtems.org/rtems.git

आंतरिक सिग्नलिंग को लागू करने के लिए, फ्रीस्केल कम से कम दो तंत्र प्रदान करता है:

इंटरप्रोसेसर इंटरप्ट्स (IPIs) - इंट्राक्लियर इंटरप्ट, मल्टीकास्ट इंटरप्ट के लिए समर्थन के साथ 4 टुकड़े तक।
संदेश इंटरप्ट्स (MSGRs) - रजिस्टर करने के लिए संदेश लिखते समय व्यवधान उत्पन्न करने के साथ 32-बिट आंतरिक संदेश, 8 टुकड़े तक।

Openmcapi लाइब्रेरी इस प्लेटफ़ॉर्म के लिए OS विशिष्ट ड्राइवर को लागू करने के लिए MSGRs तंत्र का उपयोग करती है।

साझा मेमोरी में निहित डेटा संरचना पर विचार करें (चित्र 2 देखें):

चित्रा 2. साझा मेमोरी में डेटा संरचना

अंतरिक्ष द्वारा साझा स्मृति क्षेत्र को दो ब्लॉकों में विभाजित किया जा सकता है:

पहला ब्लॉक - SHM_MGMT_BLOCK क्षेत्र, संरचना द्वारा दर्शाया गया है:

/* SM driver mamagement block */ struct _shm_drv_mgmt_struct_ { shm_lock shm_init_lock; mcapi_uint32_t shm_init_field; struct _shm_route_ shm_routes[CONFIG_SHM_NR_NODES]; struct _shm_buff_desc_q_ shm_queues[CONFIG_SHM_NR_NODES]; struct _shm_buff_mgmt_blk_ shm_buff_mgmt_blk; };

संरचना में निम्नलिखित तत्व शामिल हैं:

वैश्विक साझा मेमोरी लॉक shm_init_lock है, जिसका उपयोग साझा क्षेत्र में एन-कोर की पहुंच को अलग करने के लिए किया जाता है।
वैरिएबल shm_init_field में विज़ार्ड इनिशियलाइज़ेशन एंड कुंजी है, इनिशियलाइज़ेशन के अंत में SHM_INIT_COMPLETE_KEY मान लेता है।
Shm_routes - आंतरिक संचार लिंक के साथ राउटिंग टेबल में एक्सचेंज में शामिल कोर (नोड्स) की संख्या से CONFIG_SHM_NR_NODES संचार होता है। हमारे मामले में, 2 नोड्स।
Shm_queues - एक विशिष्ट नोड से जुड़ी संदेश कतारें, CONFIG_SHM_NR_NODES हैं। हमारे मामले में, 2 लाइनें।
Shm_buff_mgmt_blk - डेटा क्षेत्र में बफर प्रबंधन संरचना (SHM_BUFFER)।

दूसरा क्षेत्र , डेटा क्षेत्र, SHM_BUFF_COUNT (डिफ़ॉल्ट रूप से 128) SHM_BUFFER संरचनाएं हैं। यह क्षेत्र सीधे प्रेषित डेटा को संग्रहीत करने का कार्य करता है। SHM_BUFFER संरचना में MCAPI_MAX_DATA_LEN आकार का एक सरणी और एक अतिरिक्त तत्व नियंत्रण संरचना शामिल है।

पोर्टिंग प्रक्रिया पर विचार करने से पहले, साझा मेमोरी के माध्यम से निम्न-स्तरीय संचार तंत्र का एक ब्लॉक आरेख देना आवश्यक है (तंत्र OpenMCAPI में लागू किया गया है, अंजीर देखें 3):

चित्रा। 3. साझा स्मृति (ओपनएमसीएपीआई में कार्यान्वित) के माध्यम से संचार के निम्न-स्तरीय तंत्र के एसडीएल आरेख।

आरेखों के लिए कुछ स्पष्टीकरण:

"HW- अधिसूचना" - आरेख किसी दूरस्थ या वर्तमान कर्नेल को सूचना भेजने की प्रक्रिया का वर्णन करता है:
1. फ़ंक्शन कॉल कर्नेल की आईडी लेता है जिसके लिए संदेश का उद्देश्य है (ओपनमेकपी_शम_नोटिफाई फंक्शन)।
2. यदि अधिसूचना "लक्ष्य आईडी" दूरस्थ कर्नेल के लिए अभिप्रेत है, तो एक दूरस्थ संदेश MSGRs तंत्र के माध्यम से उत्पन्न होता है (ऊपर चर्चा की गई) एक के बराबर डेटा फ़ील्ड में मान के साथ (ब्लॉक 3 देखें), अन्यथा बाधा_हैंडल हैंडलर को स्पष्ट रूप से ("HW-Receive" आरेख) कहा जाता है। ), ब्लॉक 4 देखें।
"HW-Receive" - आरेख किसी दूरस्थ या वर्तमान कर्नेल से सूचनाएं प्राप्त करने की प्रक्रिया का वर्णन करता है:
1. Interrupt_handle एक बाधा हैंडलर है जिसे MSGRs पर संदेश प्राप्त होने पर ट्रिगर किया जाता है, इसका उपयोग एक स्पष्ट कॉल के लिए भी किया जाता है।
2. ब्लॉक 2-6 में, सभी MSGRs संदेशों की स्थिति जाँची जाती है; यदि MSGR संदेश का डेटा फ़ील्ड 0 नहीं है, तो स्ट्रीम अनलॉक हो जाती है, जो साझा मेमोरी क्षेत्र में डेटा को संसाधित करता है।
3. ब्लॉक 7-8 में, जिस स्थान पर इंटरप्ट हैंडलर कहा जाता है ("इंटरप्ट_हैंडलर") की जाँच की जाती है। यदि कॉल एक बाधा में था, तो MSGR संदेश उपस्थिति ध्वज रीसेट हो जाता है।

RTEMS के लिए पोर्टिंग विवरण पर आगे बढ़ने से पहले, हम इस OS की संक्षिप्त समीक्षा करते हैं।

RTEMS (मल्टीप्रोसेसर सिस्टम के लिए रियल-टाइम एक्जीक्यूटिव) एक ओपन-सोर्स RTOS, फुल-फीचर्ड रियल-टाइम ऑपरेटिंग सिस्टम है, जिसमें कई ओपन स्टैंडर्ड एप्लिकेशन प्रोग्रामिंग इंटरफेस (APIs), POSIX मानक और BSD सॉकेट्स के लिए समर्थन है। यह अंतरिक्ष, चिकित्सा, नेटवर्क और कई अन्य एम्बेडेड उपकरणों में उपयोग के लिए है। RTEMS में ARM, PowerPC, Intel, Blackfin, MIPS, Microblaze आदि जैसे प्रोसेसर आर्किटेक्चर की एक विस्तृत श्रृंखला शामिल है। इसमें विशेष रूप से tcp / ip, http, ftp, telnet में कार्यान्वित नेटवर्क प्रोटोकॉल का एक बड़ा स्टैक होता है। आरटीसी, नंद, UART और अन्य उपकरणों के लिए मानकीकृत पहुँच प्रदान करता है।

चलिए OpenMCAPI को पोर्ट करने की प्रक्रिया पर चलते हैं। लिंक पर स्थित दस्तावेज़ के आधार पर [1] यह आवश्यक है:

OS परत लागू करें, फाइलें:
- libmcapi / mcapi / rtems / mcapi_os.c;
- libmcapi /include/rtems/mgc_mcapi_impl_os.h
संगत साझा मेमोरी ट्रांसपोर्ट के लिए समर्थन लागू करें, फ़ाइल:
- libmcapi / shm / rtems / shm_os.c।
OpenMCAPI के लिए उपयोग किए जाने वाले वफ़ -बिल्डर में व्यंजनों को जोड़ें।

चूंकि लक्ष्य प्लेटफ़ॉर्म P1020 (पावरपीसी, 500 वी 2) और पोर्टिंग को आरटीओएस पर किया गया था, जहां कर्नेल / उपयोगकर्ता के अंतरिक्ष पृथक्करण की अनुपस्थिति की अनुमति है, लिखने की आवश्यकता नहीं है:

libmcapi / शामिल / arch / powerpc / atomic.h;
libmcapi / shm / rtems / kmod /।

इसके अलावा, OS लेयर को कार्यान्वित करने की कोई आवश्यकता नहीं है, क्योंकि RTEMS POSIX- संगत कॉल का समर्थन करता है, फाइलें mcapi_os.c और mgc_mcapi_impl_os.h केवल लिनक्स के लिए कार्यान्वयन से कॉपी की गई थीं।

साझा मेमोरी ट्रांसपोर्ट के कार्यान्वयन को पूरी तरह से shm_os.c फ़ाइल में लागू किया गया है और इसमें ट्रांसपोर्ट जेनरिक एब्स्ट्रैक्शन लेवल (फ़ाइल libmcapi / shm / shm.c) से कॉल का अनुकूलन और MSGR के माध्यम से एक्सचेंज तंत्र का कार्यान्वयन शामिल है।

कार्यान्वयन के लिए आवश्यक कार्य:

1) mcapi_status_t openmcapi_shm_notify (mcapi_uint32_t unit_id, mcapi_uint32_t नोड_id) - फ़ंक्शन दूरस्थ कोर (ओं) को एक अधिसूचना भेजता है, कार्यान्वयन एक आरेख (चित्र 3 देखें) द्वारा दर्शाया गया है। स्रोत कोड नीचे है:

 /* send notify remote core */ mcapi_status_t openmcapi_shm_notify(mcapi_uint32_t unit_id, mcapi_uint32_t node_id) { mcapi_status_t mcapi_status = MCAPI_SUCCESS; int rc; rc = shm_rtems_notify(unit_id); if (rc) { mcapi_status = MGC_MCAPI_ERR_NOT_CONNECTED; } return mcapi_status; } static inline int shm_rtems_notify(const mcomm_core_t target_core) { struct mcomm_qoriq_data *const data = &mcomm_qoriq_data; /* If the target is the local core, call the interrupt handler directly. */ if (target_core == mcomm_qoriq_cpuid()) { _mcomm_interrupt_handler(NO_IRQ, data); } else { mcomm_qoriq_notify(target_core); } return 0; } /* Wake up the process(es) corresponding to the mailbox(es) which just received * packets. */ static int _mcomm_interrupt_handler(rtems_vector_number irq, struct mcomm_qoriq_data *data) { register int i; void *mbox = data->mbox_mapped; for (i = 0; i < data->nr_mboxes; i++) { int active; switch (data->mbox_size) { case 1: active = readb(mbox); break; case 4: active = readl(mbox); break; default: active = 0; } if (active) { LOG_DEBUG("%s: waking mbox %d\n", __func__, i); (void) rtems_event_send( data->rid, MMCAPI_RX_PENDING_EVENT ); } mbox += data->mbox_stride; } if (irq != NO_IRQ) { mcomm_qoriq_ack(); } return 0; }

2) mcapi_uint32_t openmcapi_shm_schedunitid (शून्य) - फ़ंक्शन वर्तमान कर्नेल की संख्या (अर्थात, इस कोड को निष्पादित करने वाला कर्नेल ) लौटाता है, इसे प्रोसेसर रजिस्टर को पढ़कर tialially लागू किया जाता है। स्रोत कोड नीचे है:

 /* Get current cpu id */ mcapi_uint32_t openmcapi_shm_schedunitid(void) { return (mcapi_uint32_t) ppc_processor_id(); }

3) mcapi_status_t openmcapi_shm_os_init (शून्य) - फ़ंक्शन बनाता है और एक निम्न-स्तरीय डेटा प्राप्त करने की स्ट्रीम शुरू करता है, जिसे rtems_task_create और rtems_task_start फ़ंक्शन को कॉल करके कार्यान्वित किया जाता है। स्रोत कोड नीचे है:

 /* Now that SM_Mgmt_Blk has been initialized, we can start the RX thread. */ mcapi_status_t openmcapi_shm_os_init(void) { struct mcomm_qoriq_data *const data = &mcomm_qoriq_data; rtems_id id; rtems_status_code sc; if( RTEMS_SELF != data->rid ) { return MCAPI_ERR_GENERAL; } sc = rtems_task_create( rtems_build_name( 'S', 'M', 'C', 'A' ), MMCAPI_RX_TASK_PRIORITY, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id); if( RTEMS_SUCCESSFUL != sc ) { return MCAPI_ERR_GENERAL; } /* global save task id */ data->rid = id; sc = rtems_task_start( id, mcapi_receive_thread, 0 ); if( RTEMS_SUCCESSFUL != sc ) { perror( "rtems_task_start\n" ); return MCAPI_ERR_GENERAL; }; return MCAPI_SUCCESS; } static rtems_task mcapi_receive_thread(rtems_task_argument argument) { int rc; do { rc = shm_rtems_wait_notify(MCAPI_Node_ID); if (rc < 0) { perror("shm_rtems_wait_notify"); break; } MCAPI_Lock_RX_Queue(); /* Process the incoming data. */ shm_poll(); MCAPI_Unlock_RX_Queue(0); } while (1); printk("%s exiting!\n", __func__); } static inline int shm_rtems_wait_notify(const mcapi_uint32_t unitId) { rtems_event_set event_out; int ret = 0; while(1) { LOG_DEBUG("mcomm_mbox_pending start\n"); (void) rtems_event_receive( MMCAPI_RX_PENDING_EVENT, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT, &event_out ); LOG_DEBUG("rtems_event_receive\n"); ret = mcomm_mbox_pending(&mcomm_qoriq_data, (mcomm_mbox_t)unitId); LOG_DEBUG("mcomm_mbox_pending end ret=%d\n", ret); if(ret != 0) { return ret; }; } return 0; }

4) mcapi_status_t openmcapi_shm_os_finalize (शून्य) - फ़ंक्शन rtems_task_delete फ़ंक्शन को कॉल करके कार्यान्वित निम्न-स्तरीय डेटा प्राप्त करने वाली स्ट्रीम को रोकता है। स्रोत कोड नीचे है:

 /* Finalize the SM driver OS specific layer. */ mcapi_status_t openmcapi_shm_os_finalize(void) { struct mcomm_qoriq_data *const data = &mcomm_qoriq_data; rtems_id id = data->rid; rtems_status_code sc; sc = rtems_task_delete(id); if( RTEMS_SUCCESSFUL != sc ) { return MCAPI_ERR_GENERAL; } return MCAPI_SUCCESS; }

5) void * openmcapi_shm_map (शून्य) - MSGRs इंटरफ़ेस को तैयार करने और कॉन्फ़िगर करने का कार्य, साझा की गई मेमोरी तैयार करना। स्रोत कोड नीचे है:

 /* full open mcom device and get memory map addres*/ void *openmcapi_shm_map(void) { void *shm; int rc; size_t shm_bytes; // low level init // mcomm_qiroq_probe(); shm_bytes = shm_rtems_read_size(); if (shm_bytes <= 0) { perror("read shared memory size\n"); return NULL; } /* initialized device. */ rc = shm_rtems_init_device(); if (rc < 0) { perror("couldn't initialize device\n"); goto out; } shm = shm_rtems_read_addr(); if (shm == NULL) { perror("mmap shared memory"); goto out; } return shm; out: return NULL; } static size_t shm_rtems_read_size(void) { struct mcomm_qoriq_data *const data = &mcomm_qoriq_data; return (size_t) (data->mem.end - data->mem.start); } static inline int shm_rtems_init_device(void) { struct _shm_drv_mgmt_struct_ *mgmt = NULL; /* xmmm */ return mcomm_dev_initialize(&mcomm_qoriq_data, (uint32_t)&mgmt->shm_queues[0].count, CONFIG_SHM_NR_NODES, sizeof(mgmt->shm_queues[0].count), ((void *)&mgmt->shm_queues[1].count - (void *)&mgmt->shm_queues[0].count)); } static void *shm_rtems_read_addr(void) { struct mcomm_qoriq_data *const data = &mcomm_qoriq_data; return (void*)data->mem.start; }

6. void openmcapi_shm_unmap (void * shm) - फ़ंक्शन MSGRs इंटरफ़ेस को बंद करता है, साझा मेमोरी के उपयोग को रद्द करता है। स्रोत कोड नीचे है:

 /* full close mcom device and revert memory */ void openmcapi_shm_unmap(void *shm) { /* deinitialized device. */ shm_rtems_deinit_device(); // low level deinit // mcomm_qoriq_remove(); } static inline int shm_rtems_deinit_device(void) { return mcomm_dev_finalize(&mcomm_qoriq_data); }

अलग-अलग, निम्न-स्तर प्राप्त स्ट्रीम फ़ंक्शन के कार्यान्वयन पर विचार करें mcapi_receive_thread (ऊपर स्रोत कोड देखें)। जब कोई थ्रेड शुरू होता है, rtems_event_receive फ़ंक्शन को कॉल करके, इसे इवेंट स्टैंडबाय मोड (RTEMS में उपलब्ध इवेंट तंत्र द्वारा कार्यान्वित) में डाल दिया जाता है। फिर, जब एक स्टार्ट इवेंट आता है, तो उसे इंटरप्ट_हैंडलर हैंडलर में भेजा जाता है (चित्र 3 देखें, "HW-Receive" आरेख), परिवर्तन साझा मेमोरी क्षेत्र में संसाधित होते हैं (ओपनमेक्पी आंतरिक फ़ंक्शन - shm_oll) () को कॉल करते हुए, इसके प्रारंभिक अवरोध के साथ। थ्रेड निष्क्रिय स्थिति में लौटता है।

ओपनएमसीएपीआई के माध्यम से लिनक्स और आरटीईएमएस की बातचीत में प्राप्त परिणाम निम्नलिखित हैं। परीक्षण बेंच एक स्थापित P1020 प्रोसेसर (2 कोर) के साथ फ्रीस्केल P1020RDB-PB से डिबग बोर्ड है। आवृत्ति: कोर आवृत्ति - 800 मेगाहर्ट्ज, DDR2 - 400 मेगाहर्ट्ज, CCB - 400 मेगाहर्ट्ज। गुठली पर 0/1, लिनक्स / RTEMS क्रमशः लॉन्च किए गए थे। एक्सचेंज दो-तरफ़ा था, 10,000 दो-तरफ़ा पार्सल पर खर्च किए गए समय को मापा। परीक्षा परिणाम तालिका में संक्षेपित हैं:

संख्या	टेस्ट विवरण	एक पैकेज के लिए समय, माइक्रोसेकंड
1	512 बाइट सममित पैकेट	37.5
2	सममित पैकेट 52430 बाइट का आकार	121
3	100 kB सममित पैकेट	346
4	1k / 100k-linux / rtems असममित पैकेज	185

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

[!] प्रश्न और टिप्पणी का स्वागत है। उन्हें लेख के लेखक रुस्लान फिलीपोविच , प्रोमवड इलेक्ट्रॉनिक्स डिजाइन सेंटर के प्रोग्रामर द्वारा उत्तर दिया जाएगा।

ओपनएमसीएपीआई: मल्टी-कोर प्रोसेसर पर लिनक्स और आरटीओएस को एक साथ चलाना

More articles: