کاربر گرامی  خوش آمدید ... 

پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا

مشخص نشده
1390
134
word
3 MB
1969
قیمت قدیم:۱۳,۴۰۰ تومان
قیمت: ۱۳,۴۰۰ تومان
دانلود مقاله
  • خلاصه
  • فهرست و منابع
  • خلاصه پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا

    پایان نامه جهت اخذ درجه کارشناسی ارشد 

     مهندسی کامپیوتر-گرایش نرم افزار  

    چکیده 

    تحمل پذیری خطا مقوله ای است که در طراحی سیستم های با قابلیت اطمینان بالا مورد استفاده قرار می گیرد .

    تحمل پذیری خطای نرم افزاری معمولاً با استفاده از افزونگی و گوناگونی حاصل  میشود که پیچیدگی اضاف های را به

    طراحی سیستم وارد می کند. دلیل این امر آن است که تحمل پذیری خطا جزو دغدغه های مداخله ای است و در هنگام

    پیاده سازی سایر واحد های نرم افزاری را تحت تأثیر قرار می دهد. پیاده سازی تاکتیک های تحمل پذیری خطا با استفاده از

    روش های سنتی از قبیل شیءگرایی، باعث کاهش قابلیت استفاده مجدد، قابلیت نگهداری، درجه واحدبندی و درک و

    فهم سیستم می شوند. برای حل این مشکل استفاده از برنامه نویسی جنبه گرا می تواند مفید واقع شود. جنبه گرایی 

    رهیافتی است که عمل جداسازی دغدغه های مداخله ای را با حمایت برنامه نویسی جنبه گرا به بهترین شکل ممکن

    انجام می دهد. استفاده از برنامه نویسی جنبه گرا یکی از روش هایی است که امروزه برای پیاده سازی تحمل پذیری خطا

    مورد توجه قرار گرفته است. در این زمینه کارهایی انجام شده است ولی هنوز برای همه تاکتیک های تحمل پذیری خطا

    از قبیل بلوک های بازیابی و برنامه نویسی چند نسخه ای مدل جنبه گرا ارائه نشده است. همچنین جای الگوهای طراحی

    در این زمینه خالی است. 

    هدف اصلی در این تحقیق، تلاش برای مدل سازی تاکتیک های تحمل پذیری خطا با استفاده از رهیافت  جنبه گرایی 

    است. بدین منظور دو تاکتیک بلوک های بازیابی و برنامه نویسی چند نسخه ای انتخاب شده اند. سعی بر آن است تا دو

    تاکتیک ذکر شده در جهت مدل سازی با رهیافت جنبه گرایی مورد بررسی قرار گیرند. دغدغه های مداخله ای در این دو

    تاکتیک شناسایی شده و با استفاده از برنامه نویسی جنبه گرا مدل سازی می شوند. سپس دو الگوی طراحی به نام های  "الگوی طراحی بلوک های بازیابی جنبه گرا" و "الگوی طراحی برنامه نویسی چند نسخه ای جنب هگر ا"  در جهت بهبود

    قابلیت استفاده مجدد، قابلیت نگهداری و واحدبندی سیستم ارائه می شود. الگوهای پیشنهادی  با انجام  یک مطالعه

    موردی و با استفاده از شاخص های جداسازی دغدغه ها، اتصال و اندازه مورد ارزیابی قرار گرفته و مزایا و معایب آنها در

    مقایسه با مدل سازی با روش شیءگرایی تشریح گردیده است. 

     

    کلمات کلیدی: تحمل پذیری خطای، جنبه گرایی، برنامه نویسی جنبه گرا، تاکتیک بلوک های بازیابی، تاکتیک

    برنامه نویسی چند نسخه ای.  

    1 مقدمه 

    از سال 1968 که توسعه سیستم های نرم افزاری به عنوان یک مشکل مهندسی مطرح شد کارهای فراوانی در جهت حل

    مشکلات پیش روی آن صورت پذیرفته و هم اکنون نیز در حال انجام است. این فعالیت ها بیشتر در جهت جداسازی

    بهتر سیستم های نرم افزاری و پیمانه بندی بخش های آن درون واحدهای منسجم و مستقل مطرح هستند به طوری که

    این واحد ها کمترین هم پوشانی را با یکدیگر داشته باشند. با به کارگیری توسعه نر مافزاری شیءگرا در کارهای

    تحقیقاتی و کاربردی مشخص شد که این شیوه در پیمانه بندی بعضی از دغدغه ها ناتوان است. این دغدغه ها که

    دغدغه های مداخله ای نامیده می شوند، دغدغه هایی هستند که نمی توانند در داخل یک واحد  قرار بگیرند، بنابراین

    مشکلاتی را برای طراحی، پیاده سازی و نگهداری سیستم فراهم  میکنند. با گسترش تحقیقات در جهت حل این مشکل

    در شیءگرایی و همچنین تکامل سایر شیوه های مناسب برای توسعه سیستم های نر مافزاری، در سال 1997 زبان

    برنامه نویسی جنبه گرا معرفی شد. زبان برنامه نویسی جنبه گرا مفهومی به نام جنبه را برای پیمان هبندی دغدغ ههای

    مداخله ای معرفی کرد. این مفهوم می توانست دغدغه های مداخله ای را در سطح پیاد هسازی به بهترین شکل پیمان هبندی

    کند. با پیدایش زبان برنامه نویسی جنبه گرا و بکارگیری آن در پروژه های مختلف مشخص شد که استفاده از زبان

    برنامه نویسی جنبه گرا می تواند مشکلات درهم پیچیدگی و پراکندگی را حل کند.  

    تحمل پذیری خطا به قابلیتی از سیستم اشاره دارد که سیستم را توانا می سازد تا حتی در صورت بروز خطا در آن بتواند

    آن خطا را پوشش داده و از خرابی سیستم جلوگیری کند. این قابلیت در بسیاری از سیست مها در زمره مهمترین

    ملزومات غیر وظیفه مندی سیستم است. برای بسیاری از سیستم ها ، عملیات نرم افزاری امن و قابل اعتماد یک نیاز مهم

    به شمار می رود، مانند کاربردهای هوافضایی، کنترل ترافیک هوایی، تجهیزات پزشکی، هسته ای، بانکداری الکترونیکی.

    هزینه و نتیجه خرابی این سیستم ها می تواند در گستره وسیعی از صدمات انسانی، مالی و غیره مطرح شود . از آنجایی

    که امروزه نرم افزار نقش اصلی را در انجام وظایف سیستم ها بر عهده دارد، بنابراین اهمیت ویژه ای نیز در میزان قابلیت

    اطمینان سیستم ها دارد. لذا برای افزایش قابلیت اطمینان، لازم است سیست مها به صورت تحم لپذیر در برابر  خطا

    طراحی شوند. تحمل پذیری خطای نرم افزاری معمولاً به وسیله افزونگی و گوناگونی به دست  می آید که پیچیدگی

    اضافه ای را به طراحی نرم افزار وارد  میکند. دلیل این امر آن است که تحم لپذیری خطا جزو دغدغه های مداخله ای

    است که در هنگام پی ادهسازی سایر واحدهای نر مافزار را تحت تأثیر قرار  میدهد. 

    1-2 طرح مسأله 

    تحمل پذیری خطا، دغدغه ای است که معمولاً پیچیدگی اضافه ای به طراحی سیستم های نرم افزار ی وارد می کند .

    پیاده سازی تحمل پذیری خطا با استفاده از روش های سنتی از قبیل شیءگرایی، باعث کاهش درک و فهم  سیستم،

    کاهش قابلیت استفاده مجدد، کاهش قابلیت نگهداری سیستم و کاهش درجه واحدبندی سیستم می شوند.  لذا به نظر

    می رسد که اگر تحمل پذیری خطا تحت یک واحد مستقل و جدای از دیگر ملزومات سیستم مورد طراحی و پیاده سازی

    قرار گیرد، منجر به کاهش پیچیدگی پیاده سازی می شود و همچنین درک و فهم سیستم و قابلیت استفاده مجدد نیز

    بهبود پیدا می کند. استفاده از برنامه نویسی جنبه گرا می تواند یک راه حل مناسب به منظور مواجهه با چالش های فوق

    باشد. در این تحقیق ضمن بررسی صحت این راه حل و پاسخ به اینکه استفاده از برنامه نویسی جنبه گرا تا چه میزان

    چالش های دغدغه تحمل پذیری خطا را بهبود می دهد، دو تاکتیک تحمل پذیری خطا به نام های بلوک های بازیابی و

    برنامه نویسی چند نسخه ای انتخاب می شوند. علت انتخاب این دو تاکتیک آن است که (1) از تاکتیک های مهم

    گوناگونی طراحی هستند (2) برای آنها تا کنون مدل جنبه گرا ارائه نشده است. دغدغه های مداخله ای دو تاکتیک ذکر

    شده شناسایی شده و با استفاده از رهیافت جنبه گرایی مدل سازی می شوند. سپس دو الگوی طراحی  بهنام های "الگوی

    طراحی بلوک های بازیابی جنبه گرا" و الگوی طراحی برنامه نویسی چند نسخه ای جنبه گر ا" در جهت بهبود قابلیت

    استفاده مجدد، قابلیت نگهداری و واحدبندی سیستم و همچنین کاهش پیچیدگی طراحی ارائه می شود . الگوهای

    طراحی پیشنهادی دارای ویژ گیهای ذیل هستند: 

    − جداسازی دغدغه تحمل پذیری خطا از نیازمندی های اصلی نرم افزار به طوریکه بتوان مقوله تحمل پذیری خطا

    را در قالب یک واحد جداگانه از سیستم بیان کرد. 

    − بهبود قابلیت استفاده مجدد سیستم 

    − بهبود قابلیت نگهداری سیستم 

    − بهبود درک و فهم سیستم 

    − کاهش پیچیدگی طراحی سیستم

    1-3 اهداف تحقیق 

    در این تحقیق تلاش می شود تا با استفاده از برنامه نویسی جنبه گرا، تاکتیک های تحمل پذیری خطا را مد لسازی نموده 

    به طوریکه قابلیت استفاده مجدد، قابلیت نگهداری و دیگر چالش های تحمل پذیری خطا بهبود یاب ند. همچنین

    دست یافتن به اینکه: تا چه میزان تاکتیک های تحمل پذیری خطا را می توان با برنامه نویسی جنبه گرا پیاده سازی کرد؟

    میزان تاثیر استفاده از برنامه نویسی جنبه گرا در بهبود چالش های تحمل پذیری خطا چقدر است؟ در تحقیق حاضر

    ضمن شناخت امکاناتی که زبان برنامه نویسی جنبه گرا فرآهم می آورد سعی می شود در جهت بهبود  چالش های 

    پیاده سازی تاکتی کهای تحمل پذیری خطا، الگوی طراحی با استفاده از رهیافت جنبه اگر یی ارائه شود. 

    1-4 محدوده تحقیق 

    برای رسیدن به سیستم های دارای قابلیت اطمینان بالا و اتکاپذیری بالا علاوه بر تحمل پذیری خطا روش های دیگری

    نیز وجود دارد که خارج از محدوده تحقیق حاضر است . این روش ها عبارتند از: اجتناب از نقص[1]، رفع نقص[2] و

    پیش بینی نقص[3] . اجتناب از نقص توسط تکنی کهای کنترل کیفیت طی مراحل تحلیل نیازمند یها، طرا حی و

    پیاده سازی انجام می شود. رفع نقص با استفاده از روش های صحت سنجی [4]، عیب یابی و تصحیح[5] حاصل می شود .

    پیش بینی نقص با انجام عملیات ارزیابی رفتار سیستم با توجه به رخداد خطا یا فعال سازی خطا صورت  میگیرد. 

    تحمل پذیری خطا می تواند به صورت سخت افزاری و یا نرم افزاری پیاده سازی شود. تحمل پذیری خطای نرم افزاری ممکن

    است در سطوح مختلف از نرم افزار از قبیل سطح سیستم عامل، لایه میانی و سطح برنامه کاربردی فراهم شود . در این

    تحقیق تحمل پذیری خطا به صورت نرم افزاری و در سطح برنامه کاربردی بحث می شود . برای توسعه مدل  های

    پیشنهادی از زبان برنامه نویسی جنبه گرا AspectC++ استفاده شده است. برای جنبه گرایی زبان های مختلفی وجود

    دارد که مهمترین آنها AspectJ است که بر پایه زبان جاوا قرار دارد. AspectC++ که بر پایه زبان C++ است به اندازه

    زبان AspectJ قدرتمند می باشد [1]. در این تحقیق سرباری که جنبه گرایی در اجرای برنامه وارد می کند، موردمحاسبه قرار نگرفته است. میزان سربار استفاده از جنبه گرایی در اجرای برنامه جزو اهداف تحقیق حاضر  نیست البته

    این خود می تواند به عنوان یک پروژه تحقیقاتی مطرح باشد. 

    1-5 مراحل انجام تحقیق 

    مراحل انجام تحقیق حاضر همان طور که در شکل 1-1 مشخص شده است، از مطالعه بر روی مقوله تحمل پذیری خطا

    آغاز می شود. در این گام ضمن پرداختن به مفهوم تحمل پذیری خطا، تاکتیک ها یی که برای تحمل پذیر  ک ردن

    سیستم های نرم افزاری وجود دارد معرفی می گردد. با معرفی مختصری از زبان برنامه نویسی جنبه گرا، استفاده از آن

    برای پیاده سازی تحمل پذیری خطا بیان می شود و  در ادامه کارهایی که در زمینه انجام شده است، مورد بررسی و

    تحلیل قرار می گیرد. نقاط ضعف و قوت آنها مشخص می شود. سپس به منظور حل چالش های مشخص شده به

    مدل سازی تاکتیک های تحمل پذیری خطا با استفاده از برنامه نویسی جنب هگرا پرداخته شده و در ادامه دو الگوی طراحی

    بر پایه جنبه گرا برای تاکتیک های بلوک های بازیابی و برنامه نویسی چند نسخه ای ارائه می شود. برای ارزیابی مدل های

    پیشنهادی مطالعه موردی بر روی برنامه مرتب سازی انجام شده، سپس مدل پیشنهادی با روش شیءگرایی مقایسه و

    نتیجه گیری می شود. در پایان جمع بندی و پیشنهاد کارهای آینده ارائه  میشود. 

    1-6 ساختار پایان نامه 

    ساختار پایان نامه حاضر در فص لهای بعدی به صورت ذیل سازما ندهی شده است: 

    در فصل دوم، مفاهیم پایه ای مورد استفاده در این تحقیق شرح داده  میشود، خلاصه ای از کارهای انجام شده در زمینه

    استفاده از جنبه گرایی برای تحمل پذیری خطا بیان شده و نقاط قوت و ضعف آنها مشخص می شوند. در فصل سوم، به

    مدل سازی دو تاکتیک تحمل پذیری خطا به نام بلوک های بازیابی و برنامه نویسی چند نسخه ای با استفاده از زبان

    برنامه نویسی جنبه گرا پرداخته شده و دو الگوی طراحی بر پایه جنبه گرایی برای آنها ارائه م یشود . در فصل چهارم،

    انجام یک مطالعه موردی و ارزیابی مدل های پیشنهادی صورت می گیرد. در فصل پنجم به عنوان آخرین فصل با

    جمع بندی و نتیجه گیری، تحقیق حاضر به پایان می رسد. 

    Abstract

     

    Fault tolerance is a means of achieving high dependability for critical and high available systems. Software fault tolerance is usually applied by means of redundancy and diversity. These mechanisms do not come for free; rather they introduce additional complexity to the core functionality. This results in tangling of core functionality with the fault tolerance concerns. Implementation of fault tolerance strategy by making use of traditional manners such object-oriented will result in reduction of system understanding, reusability, and maintainability. For solving these problems using aspect-oriented programming can be useful.

    Aspect-oriented programming can be used to address the non-functional aspects of such systems separately from the functional requirements and what benefits result from this separation of concerns. Presently, aspect-oriented programming is amongst one of methods that are being used to perform fault tolerance. However some researches have been done with this regard, still all fault tolerance strategies have not being subject to research such as recovery block and N-version programming. Also design pattern is a subject to farther research.

    The purpose of this research is to model and implementation fault tolerance strategies such as recovery blocks and N-version programming modeling using aspect-oriented programming. Therefore, to reach to this goal, two strategies were studied and their crosscutting concerns were modeled and implemented by aspect-oriented programming. Then using obtained experiences, two design patterns namely “Recovery Block Aspect Designing Pattern” and ” N-Version Programming Aspect Designing Pattern” were suggested for these strategies. At the end, by using a case study, suggested models were compared with object-oriented method ant their benefits and faults were identifie.

     

    Keywords: Software Fault Tolerance, Aspect-oriented Programming, Aspect-Oriented Recovery Block strategy, N-Version Programming Strategy.                 

  • فهرست و منابع پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا

    فهرست:

    1فصل اول: کلیات تحقیق .....................................................................................................................................

    مقدمه....................................................................................................................................................................................................  2 

    طرح مسأله  ..........................................................................................................................................................................................  3 

    اهداف تحقیق  ......................................................................................................................................................................................  4 

    محدوده تحقیق  ..................................................................................................................................................................................  4 

    مراحل انجام تحقیق  ..........................................................................................................................................................................  5 

    ساختار پایان نامه.................................................................................................................................................................................  5 

    فصل دوم: مفاهیم پایه و پیشینه تحقیق ...........................................................................................................  7 

    2-1 مقدمه....................................................................................................................................................................................................  8 

    2-2 تحمل پذیری خطا  ..............................................................................................................................................................................  8 

    2-2- 1 اتکاپذیری و تحمل پذیری خطا  ............................................................................................................................................................  8 

    2-2- 1-1 قابلیت اطمینان............................................................................................................................................................................  9 

    2-2- 1-2 قابلیت دسترسی  ..........................................................................................................................................................................  9 

    2-2- 1-3 ایمنی  ..........................................................................................................................................................................................  10 

    2-2- 1-4 قابلیت نگهداشت  ......................................................................................................................................................................  11 

    2-2- 1-5 امنیت  ..........................................................................................................................................................................................  11 

    2-2- 2 نقص، خطا و شکست  ..........................................................................................................................................................................  11 

    2-2- 3 افزونگی  ..................................................................................................................................................................................................  12 

    2-2- 4 گوناگونی طراحی  .................................................................................................................................................................................  13 

    2-2- 5 سناریوی تحمل پذیری خطا  ...............................................................................................................................................................  14 

    2-2- 5-1 سناریوی عمومی تحمل پذیری خطا  .....................................................................................................................................  15 

    2-2- 6 تحمل پذیری خطای نرم افزاری  ..........................................................................................................................................................  16 

    2-2- 7 تاکتیک های تحمل پذیری خطای نرم افزاری تک نسخه ای  ...........................................................................................................  17 

    2-2- 7-1 آشکارسازی نقص......................................................................................................................................................................  18 

    2-2- 7-2  محدودسازی نقص  ..................................................................................................................................................................  19 

    ز

     

    2-2 7-3  بازیابی نقص  .............................................................................................................................................................................20

    2-2- 8 تاکتیک های تحمل پذیری خطای نرم افزاری چند نسخه ای  ........................................................................................................  21

    2-2- 8-1 بلوک های بازیابی  ......................................................................................................................................................................  21

    2-2- 8-2 برنامه نویسی چند نسخه ای  .....................................................................................................................................................  23 

    2-2- 8-3 برنامه نویسی خود بررسی  ........................................................................................................................................................  25 

    2-2- 8-4  بلوک های بازیابی  توزیع شده  ................................................................................................................................................  27 

    2-2- 8-5  بلوک های بازیابی اجماعی  .....................................................................................................................................................  29 

    2-2- 8-6 رأی گیری پذیرش  .....................................................................................................................................................................  30 

    2-3 برنامه نویسی جنبه گرا  .....................................................................................................................................................................  32 

    2-3- 1 جداسازی دغدغه ها  ..............................................................................................................................................................................  33 

    2-3- 2 برنامه نویسی جنبه گرا  ..........................................................................................................................................................................  35 

    2-3- 2-1 جنبه  ............................................................................................................................................................................................  36 

    2-3- 2-2 نقطه اتصال  ................................................................................................................................................................................  37 

    2-3- 2-3 محل برش  ..................................................................................................................................................................................  38 

    2-3- 2-4 کد توصیه  ...................................................................................................................................................................................  38 

      39  .........................................................................................................................................................................................  AspectC++ 3 -3-2

    2-3- 4 تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا  .................................................................................................................  41 

    2-4 بررسی کارهای مرتبط  ...................................................................................................................................................................  43 

    2-4- 1 معرفی کارهای انجام شده..................................................................................................................................................................  43 

    2-4- 2 نقاط ضعف و مشکلات کارهای انجام شده  .....................................................................................................................................  47 

    2-5 جمع بندی مطالب فصل.................................................................................................................................................................  49 

    فصل سوم: مدل سازی تاکتیک های تحمل پذیری خطای نرم افزاری با استفاده از برنامه نویسی جنبه گرا  .....  51 

    3-1 مقدمه.................................................................................................................................................................................................  52 

    3-2 مدل سازی تاکتیک بلوک های بازیابی با استفاده از جنبه گرایی  ..........................................................................................  52 

    3-2- 1 بلوک های بازیابی به عنوان یک جنبه..............................................................................................................................................  53 

    3-2- 2 الگوی طراحی  بلوک های بازیابی جنبه گرا  .....................................................................................................................................  56 

    3-2- 2-1 منظور  ..........................................................................................................................................................................................  56 

    3-2- 2-2 انگیزه  ..........................................................................................................................................................................................  56 

    س

    3-2 2-3 کاربردپذیری  ..............................................................................................................................................................................57

    3-2- 2-4 ساختار الگوی پیشنهادی  ........................................................................................................................................................  57

    3-2- 2-5 سناریو  .........................................................................................................................................................................................  59

    3-2- 2-6 نتایج  ............................................................................................................................................................................................  63 

    3-2- 2-7 پیاده سازی  ..................................................................................................................................................................................  64 

    3-2- 2-8 نمونه کد  .....................................................................................................................................................................................  64 

    3-2 مدل سازی تاکتیک برنامه نویسی چند نسخه ای با استفاده از جنبه گرایی  ..........................................................................  65 

    3-2- 1 الگوی تاکتیک برنامه نویسی چند نسخه ای جنبه گرا  ..................................................................................................................  67 

    3-2- 1-1 منظور  ..........................................................................................................................................................................................  67 

    3-2- 1-2 انگیزه  ..........................................................................................................................................................................................  67 

    3-2- 1-3 کاربردپذیری  ..............................................................................................................................................................................  68 

    3-2- 1-4 ساختار  ........................................................................................................................................................................................  68 

    3-2- 1-5 سناریو  .........................................................................................................................................................................................  69 

    3-2- 1-6 نتایج  ............................................................................................................................................................................................  70 

    3-2- 1-7 پیاده سازی  ..................................................................................................................................................................................  71 

    3-2- 1-8 کد نمونه  .....................................................................................................................................................................................  71 

    3-3 جمع بندی مطالب فصل.................................................................................................................................................................  72 

    فصل چهارم: مطالعه موردی و ارزیابی .............................................................................................................  74 

    4-1 مقدمه.................................................................................................................................................................................................  75 

    4-1 شاخص ها و معیارهای ارزیابی  ......................................................................................................................................................  75 

    4-1- 1 معیارهای جداسازی دغدغه ها  ...........................................................................................................................................................  75 

    4-1- 1-1 پخش دغدغه بر روی مولفه ها (CDC).................................................................................................................................  75 

    4-1- 1-2 پخش دغدغه بر روی متدها (CDO)  ...................................................................................................................................  76 

    4-1- 2 معیار اتصال  ...........................................................................................................................................................................................  76 

    4-1- 2-1 اتصال بین مولفه ها (CBC)  ....................................................................................................................................................  76 

    4-1- 2-2 عمق درخت وراثت (DIT)  ......................................................................................................................................................  76 

    4-1- 3 معیار اندازه  ............................................................................................................................................................................................  77 

    4-1- 3-1 تعداد اجزاء (VS)......................................................................................................................................................................  77 

    ش

    4-1 3-2 تعداد خصوصیات (NOA)  ......................................................................................................................................................77

    4-2 مطالعه موردی  .................................................................................................................................................................................  77

    4-2- 1 برنامه مرتب سازی با تاکتیک بلوک های بازیابی به روش شیءگرایی  ........................................................................................  78

    4-2- 2 برنامه مرتب سازی با تاکتیک بلوک های بازیابی جنبه گرا  ............................................................................................................  79 

    4-2- 3 برنامه مرتب سازی با تاکتیک برنامه نویسی چند نسخه ای به روش شیءگرایی  ......................................................................  81 

    4-2- 4 برنامه مرتب سازی با تاکتیک برنامه نویسی چند نسخه ای جنبه گرا...........................................................................................  82 

    4-2- 3 ارزیابی  ....................................................................................................................................................................................................  83 

    4-3 نتیجه گیری  .......................................................................................................................................................................................  85 

    4-4 جمع بندی مطالب فصل..................................................................................................................................................................  86 

    فصل پنجم: خلاصه و نتیجه گیری  ....................................................................................................................  87 

    5-1 مقدمه.................................................................................................................................................................................................  88 

    5-2 بازبینی میزان تحقق اهداف پایان نامه  ........................................................................................................................................  88 

    5-3 ویژگی نوآوری های تحقیق  ............................................................................................................................................................  89 

    5-4 محدودیت ها......................................................................................................................................................................................  90 

    5-5 نتیجه گیری  .......................................................................................................................................................................................  90 

    5-6 کارهای آینده  ...................................................................................................................................................................................  91 

    مراجع  ..........................................................................................................................................................................................................  93 

                

    ص

     

    جدول 2-2 تاکتیک های پیاده سازی شده با برنامه نویسی جنبه گرا 63

    جدول 4-1 برنامه های پیاده سازی شده در مطالعه موردی... 99

     

    منبع:

     

    AspectC++ project homepage.  http://www.aspectc.org

    A., Laprie, J.C., Randell, B. and Landwehr Avizienis, "Basic Concepts and Taxonomy of Dependable and Secure Computing," IEEE Transactions on Dependable and Secure Computing, vol. 1, no. 1, pp. 11-33, March 2004.

    J.H. and Harper, R.E Lala, "Architectural principles for safety-critical real-time," in Proceedings of the IEEE, 82 (1), 1994, pp. 25-40.

    N Storey, Safety Critical Computer Systems.: Addison-Wesley Longman, Inc, 1996.

    Paul Clements, Rick Kazman Len Bass, Software Architecture in Practice, Second Edition ed.: Addison Wesley, 2003.

    W Torres, "Software Fault Tolerance: A Tutorial," NASA Langley Technical 2000.

    D. and Traverse, P Briere, "AIRBUS A320/A330/A340 electrical flight controls - A family of fault-tolerant systems," in Proceedings of the Twenty Third International Symposium on Fault-Tolerant Computing - FTCS-23, Toulouse, France, 1993, pp. 616-623.

    D.P Siewiorek, "Architecture of fault-tolerant computers: an historical perspective," in perspective., 1991, pp. 1710-1734.

    J.J., Lauer, H.C., Melliar-Smith, P.M. and Randell, B Horning, "A program structure for error detection and recovery," in In Proceedings of an International Symposium Operating Systems, Springer-Verlag, 1974, pp. 171 - 187.

    Elena Dubrova, Fault Tolerant Design: An Introduction. Boston/Dordrech, London: Fault Tolerant Design: An Introduction, 2007.

    L. and Avizienis, A Chen, "N-Version Programming: A fault-tolerance approach to reliability of sotware operation," in In Proceedings of FTCS-8, Tolouse, France, 1978, pp. 3-9.

    A. Avizienis, "The Methodology of N-Version Programming," in In Lyu, M.R. ed. Software fault tolerance, Wiley, 1995, pp. 23-46.

    P Traverse, "AIRBUS and ATR System Architecture and Specification," in U. Voges (ed.), Software Diversity in Computerized Control Systems, Springer-Verlag, New York, 1988, pp. 95-104.

    K.H Kim, "The distributed recovery block scheme," in In Lyu, M.R. ed. Software Fault Tolerance, Wiley, 1995, pp. 189-209.

    K.H. and Welch, H.O Kim, "Distributed execution of recovery blocks: an approach for uniform treatment of hardware and software faults in real-time applications," IEEE Transactions on Computers, pp. 38 (5): 626-636, 1989.

    Laura L. Pullum, Software Fault Tolerance Techniques and Implementation. Boston, London: artechhouse, 2001.

    H. Ossher, W. H. Harrison, and S. S. Jr. N degrees of separation P. Tarr, "Multidimensional separation of concerns," in In Proceedings of the International Conference on Software Engineering, IEEE Computer Society Press, 1999, pp. 107–119.

    E. W. Dijkstra, "On the role of scientific thought," Springer-Verlag New York, Inc, no. 0387-90652-5, pp. 60–66, 1982.

    Lionel Seinturier Renaud Pawlak, "Foundations of AOP for J2EE Development," SpringerVerlag New York, no. ISBN: 1-59059-507-6, 2005.

    Olaf Spinczyk, Daniel Lohmann, and Matthias Urban, "Advances in AOP with AspectC++," in Software Methodologies Tools and Techniques (SoMeT '05), Tokyo, Japan, 2005, pp. 3353.

    J.L., Sanchez, F., Toro, M Herrero, "Fault tolerance as an aspect using JReplica," in Proceedings of the Eighth IEEE Workshop on Future trends of Distributed Computing Systems, Los Alamitos, 2001, pp. 201–207.

    O. and Lohmann, D Spinczyk, "The design and implementation of AspectC++," in Knowledge Based Systems, 2007, pp. 636-651.

    J Fabry, "A Framework for Replication of Objects using Aspect-Oriented Programming," Phd Thesis, University of Brussel 1998.

    D., Nadjm-Tehrani, S Szentivanyi, "Aspects for improvement of performance in faulttolerant software," in Proceedings of the 10th IEEE Pacific Rim International Symposium on Dependable Computing, 2004, pp. 283–291.

    Ruben Alexandersson, "Implementing Fault Tolerance Using Aspect Oriented Programming," Springer, pp. LNCS 4746, pp. 57–74, 2007.

    Ruben Alexandersson, "Aspect-Oriented Implementation of Fault Tolerance: An Assessment of Overhead," Springer, SAFECOMP, no. LNCS 6351, pp. 466–479, 2010.

    Ruben Alexandersson, "On Hardware Resource Consumption for Aspect-Oriented

    Implementation of Fault Tolerance," in European Dependable Computing Conference,

    .0102

    RobWilliams Kashif Hameed, "Software Fault Tolerance: An Aspect Oriented Approach," Springer, Electronic Engineering and Computing Technology, no. DOI 10.1007/978-90-4818776-8 14, 2010.

    Fernando Castor filho, "Error Handling as an Aspect," in Workshop BPAOSD '07, Vancouver, BC, Canada, 2007.

    Carlos Silva, Nuno Brito, Sergio Montenegro Francisco Afonso, "Aspect-Oriented Fault Tolerance for Real Time Embedded Systems," in In Proceedings of the AOSD workshop on Aspects, components, and patterns for infrastructure software, ACM, Brussels, Belgium, 2008, pp. 1-8.

    Vincenzo De Florio, Application-Layer Fault-Tolerance Protocols.: United States of America by Information Science reference, 2009.

    B. and Jie, X Randel, "The evolution of the recovery block concept," in Lyu, M.R. ed. Software fault tolerance, Wiley, 1995, pp. 1-21.

    K.S., Shokri, E.H., Tai, A.T. and Dziegiel Jr., R.J. Tso, "A reuse framework for software fault tolerance," in In Proceedings of the 10th AIAA Computing in Aerospace Conference, San Antonio, TX, 1995, pp. 490-500.

    J., Randell, B., Rubira-Calsavara, C.M.F. and Stroud, R.J.A.S.R.J Xu, "Toward an objectoriented approach to software fault tolerance," in In Proceedings of IEEE Workshop on Fault-Tolerant Parallel and Distributed Systems, 1994, pp. 226-233.

    J., Randell, B. and Romanovsky, A Xu, "A generic approach to structuring and implementing complex fault-tolerant software," in In Proceedings of the Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing - ISORC, 2002, pp. 207-214.

    C. Chavez, "A Model-Driven Approach for Aspect-Oriented Design,"

    Pontif´ficiaUniversidade Cat´olica do Rio de Janeiro, Rio de Janeiro, Brazil, PhD thesis April 2004.

    Richard Helm, Ralph Johnson, John Vlissides The "Gang of Four": Erich Gamma, Design Patterns: Elements of Reusable Object-Oriented Software. USA: Addison-Wesley, 1994.

    C. N. Sant' anna at al, "On the Reuse and Maintenance of Aspect-Oriented Software: An Assessment Framework," in Proc of Brazilian Symp. Software Engineering, Brazil, 2003, pp. 19-34.

    J., Randel, B. and Zorzo, A.F Xu, "Implementing Software Fault Tolerance in C++ and OpenC++: an object-oriented and reflective approach," in International Workshop on Computer-Aided Design, Test and Evalution for Dependability, Beijing, China, 1996, pp. pp. 224-229.

    Wilfredo Torres-Pomales, "Software Fault Tolerance: A Tutorial," in NASA, Langley .

پروپوزال در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, گزارش سمینار در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, تز دکترا در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, رساله در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, پایان نامه در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, تحقیق در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, مقاله در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, پروژه دانشجویی در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, تحقیق دانشجویی در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, مقاله دانشجویی در مورد پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا, پروژه دانشجویی درباره پایان نامه مدل سازی تحمل پذیری خطا با استفاده از برنامه نویسی جنبه گرا

دریافت لینک دانلود به صورت خودکار بلافاصله پس از پرداخت

امکان پرداخت آنلاین از طریق کلیه کارت های عضو شتاب

تلفن تماس دفتر: 91002179-021
پشتیبانی سایت: 17-68-224-0930

ثبت سفارش
تعداد
عنوان محصول