Parallel سازی برای دات نت 2

8 10 2010

Parallel

همانطور که در دو پست قبلی مطالعه کردید در دات نت فریم ورک 4 قابلیت بسیار مفید parallel اضافه شده است. آن مجموعه کلاسها این امکان را فراهم می کنند که چندین کار در میان هسته های سیستم تقسیم شده و همزمان انجام شود. تنها عیب آن این است که فقط برای دات نت 4 در دسترس است.

برای حل این محدودیت می توان از روش های جایگزین استفاده کرد. گرچه این روشها باز هم به پای امکانات مهیا شده در دات نت 4 نمی رسد ولی باز هم بسیار راه گشا هستند. برای روش جایگزین می توان هم مستقیما از Thread ها استفاده کرد و هم از ThreadPool که کنترل thread ها را خودکار انجام می ده. البته این دو روش تفاوت فاحشی با هم دارند. تفاوت روش استفاده مستقیم از thread با threadpool عدم وابستگی به تعداد هسته cpu ها است، بدین معنا که در آن تقریبا همه آیتمها را به یکباره مورد پردازش قرار خواهند گرفت(البته به تعداد تعیین شده). اما threadpool همانند دات نت 4 عمل کرده و متدهای در حال اجرا و همزمان را به تعداد هسته cpu محدود می کند (با اندکی تفاوت). ابتدا متدی که مستقیما با thread ها کار می کند را معرفی می کنم و سپس روش threadpool را معرفی خواهم کرد.

با استفاده تابع زیر که تهیه کردم این امکان فراهم می آید که لیستی از آیتم ها را برای پردازش توسط یک متد یا رویه به طور همزمان پردازش نمایید. متد WorkAsParallel که در پایین ملاحظه می کنید دو ورودی می گیرد که ورودی اول لیستی جنریک از آیتم ها است و ورودی دوم متد پردازشگر مورد نظر که بر روی تک تک آیتم ها اجرا شده و عمل مورد تان را انجام می دهد.

public static void WorkAsParallel<T>(IList<T> itemsList, ParameterizedThreadStart itemDoWork)
{
// the maximum number of active threads
const int maxThreads = 10;
List<Thread> workers = new List<Thread>();

if (itemsList.Count > maxThreads)
{
    int currentItem = 0;
    for (int i = 0; i < maxThreads; i++)
    {
        T item = itemsList[i];
        try
        {
            Thread worker = new Thread(itemDoWork);
            worker.IsBackground = true;
            worker.Name = item.ToString();

            workers.Add(worker);

            // item index
            currentItem++;

            // start the thread
            worker.Start(item);
        }
        catch
        {
            // ignore any exception
        }
    }

    // A little break in current thread
    Thread.Sleep(5);

    do
    {
        // start waiting
        for (int i = workers.Count - 1; i >= 0; i--)
        {
            Thread worker = workers[i];

            if ((worker.ThreadState | ThreadState.Stopped) == ThreadState.Stopped)
            {
                workers.RemoveAt(i);

                // thread finished! run next irem if it is there
                if (currentItem <= itemsList.Count - 1)
                {
                    T item = itemsList[currentItem];
                    worker = new Thread(itemDoWork);
                    worker.IsBackground = true;
                    worker.Name = item.ToString();

                    workers.Add(worker);

                    // increase the item index
                    currentItem++;

                    // start the thread
                    worker.Start(item);
                }
            }
        }

        // a little break
        Thread.Sleep(5);

    } while (itemsList.Count > currentItem);

    // now all the list items are in progress

    // start waiting for them to be done
    foreach (Thread worker in workers)
    {
        // just wait for it
        // an infinity wait!
        worker.Join();
    }
}
else
{
    // all items are starting in threads
    foreach (T item in itemsList)
    {
        try
        {
            Thread worker = new Thread(itemDoWork);
            worker.IsBackground = true;
            worker.Name = item.ToString();

            workers.Add(worker);

            // start the thread
            worker.Start(item);
        }
        catch
        {
            // ignore any exception
        }
    }

    // A little break in current thread
    Thread.Sleep(5);

    // start waiting for them to be done
    foreach (Thread worker in workers)
    {
        // just wait for it
        // an infinity wait!
        worker.Join();
    }
}
}

به طور پیش فرض تعداد thread فعال 10 در نظر گرفته شده است (توسط ثابت maxThreads که قابل افزایش است) بدین معنا که در صورتی تعداد آیتمهای لیست شما بیش از 10 تا باشد ابتدا فقط 10 آیتم ابتدایی اجرا خواهند شد و تنها پس از پایان هر thread آیتم بعدی مورد پردازش قرار خواهد گرفت. این محدودیت به خاطر جلوگیری از وارد شدن فشار بیش از حد به سیستم در نظر گرفته شده و در صورت صلاحدید شما قابل افزایش است.

  • روش استفاده از WorkAsParallel

در مثال زیر یک لیست از DateTime با تاخیر زمانی 1 ثانیه چاپ می شود تا همزانی اجرا هم مشخص شود.

public void TestWorkAsParallel()
{
    List<DateTime> theList = new List<DateTime>();
    theList.Add(DateTime.Now.AddDays(1));
    theList.Add(DateTime.Now.AddDays(2));
    theList.Add(DateTime.Now.AddDays(3));

    ParallelWorks.WorkAsParallel(theList, x =>
    {
        DateTime item = (DateTime)x;
        Console.Write(item);
        Thread.Sleep(1000);
    });
}

و برای استفاده در VS 2005 که با کامپایلر CCS2 کار می کنه مثال مذبور رو به این تغییر بدید:

ParallelWorks.WorkAsParallel(theList, delegate(object x)
{
    DateTime item = (DateTime) x;
    Console.Write(item);
    Thread.Sleep(1000);
});
  • استفاده از ThreadPool

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

public class ParallelProcessor
{
    public delegate void Method();

    /// <summary>
    /// Executes a set of methods in parallel and returns the results
    /// from each in an array when all threads have completed.  The methods
    /// must take no parameters and have no return value.
    /// </summary>
    /// <param name="m"></param>
    /// <returns></returns>
    public static void ExecuteParallel(params Method[] methods)
    {
        // Initialize the reset events to keep track of completed threads
        ManualResetEvent[] resetEvents = new ManualResetEvent[methods.Length];

        // Launch each method in it's own thread
        for (int i = 0; i < methods.Length; i++)
        {
            resetEvents[i] = new ManualResetEvent(false);
            ThreadPool.QueueUserWorkItem(new WaitCallback((object index) =>
            {
                int methodIndex = (int)index;

                // Execute the method
                methods[methodIndex]();

                // Tell the calling thread that we're done
                resetEvents[methodIndex].Set();
            }), i);
        }

        // Wait for all threads to execute
        WaitHandle.WaitAll(resetEvents);
    }
}

روش استفاده آن هم همانطور که در آن پست ذکر شده آسان است.

ParallelProcessor.ExecuteParallel(() =>
{
    Console.WriteLine("The long task 1");
    Thread.Sleep(500);
}, () =>
{
    Console.WriteLine("The long task 2");
    Thread.Sleep(500);
},
() =>
{
    Console.WriteLine("The long task 3");
    Thread.Sleep(500);
});

و برای VS2005 از این روش فراخوانی استفاده کنید:

ParallelProcessor.Method[] methods = new ParallelProcessor.Method[3];
methods[0] = delegate{
    Console.WriteLine("The long task 1");
    Thread.Sleep(500);
};
methods[1] = delegate{
    Console.WriteLine("The long task 1");
    Thread.Sleep(500);
};
methods[2] = delegate{
    Console.WriteLine("The long task 1");
    Thread.Sleep(500);
};
ParallelProcessor.ExecuteParallel(methods);
  • مقایسه WorkAsParallel و ParallelProcessor در عمل

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

static void Main(string[] args)
{
    Console.WriteLine("Parallels for .NET 2, salarblog.wordpress.com");

    // The list
    List<int> taskList = new List<int>() { 1, 2, 3, 4, 5, 6 };

    var pwatch = Stopwatch.StartNew();
    ParallelWorks.WorkAsParallel(taskList, x =>
    {
        Console.WriteLine("The long task {0} started at {1}", x, DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    });
    pwatch.Stop();
    Console.WriteLine("WorkAsParallel done!");

    var twatch = Stopwatch.StartNew();
    ParallelProcessor.ExecuteParallel(delegate
    {
        Console.WriteLine("Task 1 started at " + DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    }, delegate
    {
        Console.WriteLine("Task 2 started at " + DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    }, delegate
    {
        Console.WriteLine("Task 3 started at " + DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    }, delegate
    {
        Console.WriteLine("Task 4 started at " + DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    }, delegate
    {
        Console.WriteLine("Task 5 started at " + DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    }, delegate
    {
        Console.WriteLine("Task 6 started at " + DateTime.Now.ToString("ss:fff"));
        Thread.Sleep(1000);
    });
    twatch.Stop();

    Console.WriteLine();
    Console.WriteLine("WorkAsParallel finished in {0} seconds", pwatch.Elapsed.TotalSeconds);
    Console.WriteLine("ParallelProcessor finished in {0} seconds", twatch.Elapsed.TotalSeconds);

    // wait
    Console.ReadKey();
}

نتیجه اجرا چیزی مانند این خواهد بود (این نتیجه سیستم دو هسته من هست):

WorkAsParallel v.s. ParallelProcessor

WorkAsParallel v.s. ParallelProcessor

به زمانها دقت کنید. تفاوت فاهش است، 3 ثانیه برای ParallelProcessor در مقابل 1 ثانیه برای WorkAsParallel. اما این دلیل بر بهتر بودن WorkAsParallel نیست. اگر به زمانهای شروع هر تسک نگاه کنید می بینید که تسک های متد WorkAsParallel همه تقریبا همزمان اجرا شده اند. (زمانها به صورت میلی ثانیه:ثانیه هستند). دلیل این امر را همانطور که گفتیم استفاده مستقیم از thread است.

 

در هر صورت این دو توابع در دسترس هستند و می توانید با توجه به نیاز خود هر کدام را که خواستید انتخاب کرده و مورد استفاده قرار دهید.

Advertisements




نگاهی به Parallel Extensions در دات نت 4 بخش دوم

1 10 2010

در نوشته قبلی در مورد شیوه عملکرد و به کارگیری PLINQ و Parallel ها مطالبی خواندید. در این نوشتار قصد دارم در مورد Task ها (وظایف) صحبت کرده و مروری بر نکات مهم آن داشته باشیم.

  • Task چیست

Task کلاس جدیدی است که نماینده کاری است که قرار است انجام بدهید. تسکها نیز همانند Parallel ها فقط بر روی هسته های CPU زمی شوند. به این معنا که به تعداد هسته های CPU تسک ها خواهند توانست به طور همزمان اجرا شوند. متدها و کلاسهایی برای کنترل تسک ها فراهم شده تا امکان کنترل اجرای آنها و همزمان سازی آنها را مهیا کند.

تمامی پیچیدگی کار و اعمالی قرار است بر روی تسک ها انجام بشود توسط Task Scheduler (زمان بند وظایف) پیاده شده و انجام می شود. کاری که Task Scheduler انجام می دهد مدیریت اجرای تسک ها و کنترل نحوه تقسیم آنها در میان Thread های مختلف است.

فرایندی که هنگام کار با Task Scheduler اتفاق می افتد را اینگونه می توان شرح داد:

  • هنگام ایجاد تسک، آن به صف عمومی تسک ها اضافه می شود.
  • ایجاد Thread های «کارگر» مورد نیاز برای انجام کار تسک ها توسط مدیر Thread های دات نت (Thread pool). تعداد دقیق این thread ها بستگی به فاکتور های مختلفی از جمله تعداد هسته های cpu سیستم، حجم کارهای فعلی در جریان، نوع کار در جریان دارد. برای مثال اگر مدیر thread ها تشخصی دهد که فرایندها در مرحله کار با I/O دارای تاخیر هستند (مانند ذخیره یا دانلود فایل) تعداد thread بیشتری را برای افزایش سرعت ایجاد خواهد کرد. همچنین فرایند پشت زمینه ای هم همزمان هر 0.5 ثانیه پایان کار thread ها را بررسی می کند که اگر هیچ کدام به پایان نرسیده باشد، thread جدیدی را برای انجام کار ایجاد کند.
  • هر thread کارگر تسک ها را از صف عمومی تسک ها برداشته و به صف داخلی خود برای اجرا انتقال می دهد.
  • هر thread کارگر تسک های صف داخلی خود را انجام می دهد.
  • اگر هر thread صف داخلی خود را به پایان برساند، از صف thread های دیگر کارهای در انتظار را از آخر صف برداشته و پردازش می کند.
  • نموداری از فرایند بالا را مشاهده کنید:
روند کار مدیر تسک ها

روند کار مدیر تسک ها

  • ایجاد و مدیریت تسکها

ایجاد و به کار گیری تسک ها بسیار ساده و آسان است. برای ایجاد تسک از دو طریق می توان اقدام کرد. متد Task.Factory.StartNew که ورودی تابع مورد نظر (از نوع action delegate) را دریافت کرده و فورا شروع به کار می کند. مانند مثال زیر:

Task test = Task.Factory.StartNew(() => Console.WriteLine("hello"));

و یا اینکه مستقیما نمونه جدید از کلاس Task ایجاد کنید که ورودی آن هم تابع مورد نظر برای اجرا خواهد بود. برای اجرای تسک سپس باید متد Start را فرواخوانی بکنید:

Task test= new Task(() => Console.WriteLine("hello"));
test.Start();

انتظار برای پایان تسک

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

متد Task.Wait سبب انتظار برای پایان تسک مورد نظر خواهد شد. برای انتظار به چندین تسک از متد Task.WaitAll استفاده کنید که چندین تسک را به عنوان ورودی دریافت می کند و رویه اجرای برنامه تا پایان همه آنها منتظر خواهد بود.

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

مثالی از کاربرد این متد ها:

Task task1 = Task.Factory.StartNew(() => Console.WriteLine("task 1"));
Task task2 = new Task(() => Console.WriteLine("hello task 2"));
Task task3 = Task.Factory.StartNew(() => Console.WriteLine("task 3")); 

task2.Start(); 

task1.Wait();
Task.WaitAll(task2, task3);

با استفاده از ویژگی IsComplete نیز میتوانید به پایان رسیدن یک تسک را مورد آزمایش قرار دهید.

ترتیب اجرا

در صورتی که نیاز داشته باشید تا حتما پس از پایان یک تسک، تسک بعدی اجرا شود تابع ContinueWith برای همین منظور در نظر گرفته شده است. این تابع باید بر روی تسک مورد نظر فراخوانی شود. در این صورت متد ارسالی به ContinueWith بعد از تسک مورد نظر فراخوانی خواهد شد.

Task task = Task.Factory.StartNew(() => Console.WriteLine(" task 1"))
.ContinueWith(x=>  Console.WriteLine("task 2") )
.ContinueWith(x=>  Console.WriteLine("task 3") )
.ContinueWith(x=>  Console.WriteLine("task 4") );

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

همچنین تابع ContinueWith ورودی از نوع TaskContinuationOptions را دریافت می کند که امکان تعیین شرط برای اجرای تسک را فراهم و همچنین ویژگیهای ویژه ای را برای تسک تعیین می کند. برای مثال با تعیین TaskContinuationOptions.OnlyOnFaulted به عنوان شرط، تسک بعدی فقط در صورت شکست اجرای تسک قبلی اجرا خواهد شد. برای اطلاع بیشتر راجع به سایر مقادیر به راهنمای msdn مراجعه کنید.

دریافت خروجی از تسک

برای دریافت خروجی کافی هست که در متد تسک مورد نظر خروجی را ارسال کنیم ( در حقیقت داریم از Func delegate استفاده می کنیم). در این صورت خروجی از طریق ویژگی Result در دسترس خواهد بود.

var data = Task.Factory.StartNew(() => GetResult());
Console.WriteLine("Parallel task returned with value of {0}", data.Result);

Task<string> t = new Task<string>(()=>{
return "hello";
});
t.Start();
Console.WriteLine("The result is {0}", t.Result);

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

  • تداخل با UI

هنگام کار با thread ها نمی توانید مقادیر کنترل ها را تغییر بدهید به عبارت دیگر، به thread مربوط به GUI دسترسی نخواهید داشت. (این محدودیت به علت جلوگیری از مشکلات احتمالی توسط دات نت اعمال شده است).

با توجه به اینکه Task هم از thread ها برای اجرای متدهایش استفاده می کند همین مشکل نیز در استفاده از آنها وجود دارد. راه حل این مشکل بسیار ساده می باشد.

برای حل این مشکل با استفاده از تابع TaskScheduler.FromCurrentSynchronizationContext که مدیر تسک های(TaskScheduler) جدیدی را برای thread فعلی ایجاد کرده و بر میگرداند. حال اگر این تابع را در فرم اجرا کنیم محیط اجرا در thread GUI قرار خواهد داشت. سپس کافی است تا این مقدار را به سازنده تسک و یا ادامه دهنده آن (ContinueWith) ارسال کنیم. در این صورت تسک مورد نظر در thread فرم اجرا خواهد شد و در نتیجه تغییر کنترل ها بدون مشکل میسر خواهد بود.

private void button1_Click(object sender, EventArgs e)
{
    var ui = TaskScheduler.FromCurrentSynchronizationContext();

    Task.Factory.StartNew(() =>
    {
        return LoadAndProcessImage(); // compute the image

    }).ContinueWith(t =>
    {

        pictureBox1.Image = t.Result; // display it

    }, ui);
}

در این مثال ابتدا پردازش مورد نظر انجام می شود سپس در تسک بعدی که در thread مربوط به GUI اجرا خواهد شد، نتیجه به کنترل تصویر تخصیص داده می شود.

موفق باشید.

  • منابع

APress – Pro .NET 4 Parallel Programming in C#
APress – Introducing .NET 4.0
What’s new in Beta 1 for the Task Parallel Library?

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





نگاهی به Parallel Extensions در دات نت 4 بخش اول

10 06 2010

Parallel Extensions مجموعه ای کلاسها متدها و روشهایی هست که به دات نت 4 اضافه شده و امکان اجرای درخواستها و متد ها را به صورت موازی می دهد. به طور دقیق تر در این روش برنامه می تواند برخی درخواستهای خاص را به صورت موازی در چند هسته CPU به طور همزمان اجرا کند بدون اینکه در روند عادی اجرای برنامه وقفه ای ایجاد شود ویا نیاز به تغییر عمده ای داشته باشد.

شاید بپرسید که Threading همین کار را انجام می دهد و چه نیازی به استفاده از این روش وجود دارد. در پاسخ باید گقت Parallelization (یا همزمان سازی) کاربردی نسبتا متفاوت از کاربرد thread ها دارد، گرچه خود شیوه parallel از thread ها استفاده می کند. در حقیقیت parallel ها برای استفاده سریع تر از thread ها در مقاصد خاص ایجاد شده اند و نه جایگزینی برای آن؛ جایی که تعداد زیادی از thread باعث ایجاد مشکلات مدیریتی می شود.

  • فرق بین Threading و Parallel

به طور خلاصه می توان چند thread را در یک cpu تک هسته ای اجرا کرد ولی parallel سازی فقط در cpu های چند هسته ای اتفاق خواهد افتاد. در هنگام استفاده از parallel ها دات نت به طور خودکار اقدام به شناسایی سیستم برای دارا بودن cpu چند هسته ای می کند، در صورتی سیستم دارای چنین قابلیتی باشد دات نت اقدامات بعدی را برای اجرای پروسه به صورت parallel انجام خواهد داد. این یکی از مزایای این روش هست که تضمین می کند کد برنامه در هر سیستمی قابل اجرا خواهد بود.

در تصویر زیر مشاهده میکنید که thread ها  در یک سیستم تک هسته ای به صورت ترتیبی اجرا می شود و parallel در یکی سیستم چند هسته ای همزمان اجرا می شود.
(توجه کنید که thread ها هم در سیستم چند هسته ای می توانند در هسته های مختلف می توانند اجرا شوند ولی تضمینی برای اجرای همزمان آنها وجود ندارد و کنترل آن توسط سیستم عامل انجام می شود.)

Serial vs. Parallel

Serial vs. Parallel

  • Parallel Loops

دو متد Parallel.For و Parallel.ForEach که در فضای نام System.Threading.Tasks قرار دارند برای انجام حلقه های پارالل در نظر گرفته شده اند. نسخه های مختلفی از آنها با توجه به ورودی و خروجی این متد ها در نظر گرفته شده تا همه شرایط را پوشش دهند. اما برای استفاده از لازم نیست که حتما از این توابع استفاده کنید. متد اضافه شونده AsParallel که جزوی از PLINQ برای راحتی کار در نظر گرفته شده است.
همه لیست ها و آرایه هایی که اینترفیس IEnumerable رو پیاده سازی می کنند بسادگی و با استفاده از متد اضافه شوند (extension method) با نام AsParallel امکان استفاده از پارالل ها را دارند. این متد که در مبحث PLINQ کاربرد دارد کار را بسیار ساده کرده و روش استفاده از آن در حد یک فراخوانی ساده کرده است.

در مثال ساده زیر یک حلقه از 0 تا 100 داریم که به صورت پارالل اجرا می شود. در بخش بعدی در مثالی در مورد AsParallel را مشاهده خواهید کرد.

Parallel.For(0, 100, index =>
{
     Console.WriteLine("Id:{0} Num:{1} - ", Task.CurrentId, index);
});

در اینجا Task.CurrentId مقدار id تسک در حال اجرا نشان می دهد. در بخش بعدی در مورد تسک ها خواهم نوشت.

  • کارایی Parallel سازی

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

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

همچنین در هنگام استفاده از parallel ها همیشه در نظر داشته باشید که بهترین نتیجه را زمانی خواهید گرفت که cpu سیستم دارای چند هسته باشد. در غیر این صورت این روش ممکن است اندکی سربار ایجاد کند.

درمثال زیر می خواهیم یک کار زمانبر را دو روش parallel و serial اجرا کنیم و نتایج را بررسی کنیم.

class LongTask
{
 public int ID { get; set; }
 public void DoIt()
 {
  Console.WriteLine("The long task " + ID);
  System.Threading.Thread.Sleep(500);
 }
}
static void Main(string[] args)
{

  // The list
  List<LongTask> taskList = new List<LongTask>();

  // The items
  for (int i = 0; i < 20; i++)
  {
   taskList.Add(new LongTask { ID = i });
  }

  // Serial
  Console.WriteLine("Starting serial test");
  var swatch = Stopwatch.StartNew();
  foreach (var item in taskList)
  {
   // the long task
   item.DoIt();
  }
  swatch.Stop();

  // parallel
  Console.WriteLine("Starting parallel test");
  var pwatch = Stopwatch.StartNew();
  taskList.AsParallel().ForAll(x =>
  {
   x.DoIt();
  });
  pwatch.Stop();

  Console.WriteLine();
  Console.WriteLine("Parallel programming demo, salarblog.wordpress.com");
  Console.WriteLine("Serial task finished in {0} seconds", swatch.Elapsed.TotalSeconds);
  Console.WriteLine("Parallel task finished in {0} seconds", pwatch.Elapsed.TotalSeconds);

  // wait
  Console.ReadKey();
}

تصویر زیر نتیجه اجرای این برنامه را در لپتابم که cpu اون core 2 due 2.6 دو هسته ای هست رو نشان میده.

Parallel Performance Test

Parallel Performance Test

تفاوت فاهش هست. 10 ثانیه برای serial و 5 ثانیه برای parallel. مدت زمان اجرا با استفاده از parallel تقریبا نصب شده است. البته این بهترین حالت برای یک سیستم دو هسته ای است چون این تست هیچ فشاری رو روی سیستم وارد نمی کنه.

نکته بسیار مهم: اگه به تصویر بالا دقت کنید در هنگام اجرای تست parallel تسک ها بدون ترتیب و در هم اجرا شده اند. این به این علت است که تسک ها در میان هسته های cpu تقسیم شده اند تا تداخلی در هنگام اجرا ایجاد نشود. نحوه تقسیم را هم دات نت تنظیم می کند که در ایجا و برای cpu دو هسته ای برای یک هسته از اول تا وسط و برای هسته بعدی از وسط تا آخر پردازش شده است.

پس همیشه در استفاده از parallel ها دقت کنید که آیا نیاز دارید که لیست به صورت مرتب بررسی شود یا نه. در صورتی که لازم است لیست به صورت مرتب پارالل شود باید از متد Parallel.For که قبلا اشاره شد استفاده کنید. این متد تظمین می کند که لیست شما مرتب و در عین حال parallel اجرا شود. شیوه رفع این مشکل در PLINQ در ادامه گفته خواهد شد.

دو متد Parallel.For و Parallel.ForEach کلاس ParallelOptions را به عنوان ورودی قبول می کنند که کنترل بیشتری بر تسک ها در اخیار می گذارد. برای اطلاعات بیشتر در مورد ParallelOptions به منابع انتهای مقاله مراجه کنید.

نکته مهم – اشتباه به کار گیری: نکته دیگری که لازم به ذکر است این است که نباید لیست هایی که توسط تابع AsParallel به لیست های پارالل تبدیل شده اند را توسط دستور foreach ساده فراخوانی کرد. برای مشاهده نتیجه دقیق کد زیر را در مثال بالا جایگزین کرده و اجرا کردم نتیجه آن را در تصویر زیر می بینید:

foreach (var item in taskList.AsParallel())
{
 // the long task
 item.DoIt();
}
Wrong Parallel Usage

Wrong Parallel Usage

همانطور که مشاهده می کنید نه تنها استفاده از ناصحیح از پارالل باعث کاهش زمان نشده بلکه چند میلی ثانیه این زمان بیشتر نیز شده است. دلیل این است که با استفاده از متد AsParallel یک لیست parallel بدست می آوریم ولی دستور foreach ساده این لیست را به طور ساده و serial اجرا می کند و هیچ عمل پارالل سازی اتفاق نمی افتد.

  • PLINQ – Parallel LINQ

اگر دقت کرده باشید من در مثالهای قبلی از PLINQ استفاده کرده ام که قلب اصلی آن متد AsParallel هست.  PLINQ نسخه parallel شده LINQ هست که علاوه بر متد ذکر شده شامل متدهای دیگری برای مدیریت ویژگی parallel آن هم هست. تعدادی از این متد های اصلی در لیست زیر را ذکر می کنم:

  • AsParallel: همانظور که ذکر شد یک پرس و جوی LINQ را به یک پر جوی PLINQ تبدیل می کند. به طور دقیق تر یک شیء ParallelQuery را از روی IEnumerable ایجاد می کند. ParallelQuery نماینده یک پرس و جوی PLINQ می باشد.
  • AsSequential: عکس کار متد AsParallel را انجام می دهد، یعنی یکی پرس و جوی پارالل را به یک پرس و جوی معمولی linq تبدیل می کند.
  • AsOrdered: پرس و جوی پارالل را مجبور می کند که به ترتیب اجرا شود. این دقیقا همان راه حل مشکلی است که در بالا برای درهم اجرا شدن تسک های parallel ذکر شد. این راه حل برای نسخه PLINQ کاربرد دارد.
  • AsUnordered: عکس متد بالا را انجام می دهد.

استفاده از موارد فوق در پرس و جو ها به سادگی امکان پذیر است:

var resultSet = from t in taskList.AsParallel()
 select t;

متد ForAll: کاربرد این متد برای PLINQ در این است که بدون کش کردن و تلفیق کردن(result merging) نتیجه را فورا بر می گرداند. این باعث خواهد شد که نتایج AsOrdered نادیده گرفته بشوند. برای کنترل بیشتر در مورد نحوه کش کردن و تلفیق کردن نتایج از متد WithMergeOptions که ورودی از نوع ParallelMergeOptions می گیرد را استفاده کنید.

بخش دوم این مقاله در مورد Task ها خواهد بود.

موفق باشید.

  • منابع و لینک های مفید:

APress – Pro .NET 4 Parallel Programming in C#
APress – Introducing .NET 4.0
O’Reilly – C# 4.0 IN A NUTSHELL
Threading/Concurrency vs Parallelism
How to: Control Ordering in a PLINQ Query
Why is ParallelQuery.Where not working when converting to Observable?

نگاهی به Parallel Extensions در دات نت 4 بخش اول





نصب و رفع مشکلات راهنمای Visual Studio 2010

11 05 2010

ماکروسافت در نسخه جدید Visual Studio سیستم راهنمای آن را که همنام با کتابخانه  راهنمای ماکروسافت به نام MSDN هست تغییر داده است. در این سیستم که اصطلاحا Help Viewer 1.0 نام دارد، دیگر از Document Explorer خبری نیست و راهنما می تواند در هر مرورگری نمایش داده شود. با این تفاوت که مرورگر پیش فرض صفحات راهنما، خود Visual Studio است.

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

  • نصب راهنما

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

جهت نصب از طریق Visual Studio از منوی Help گزینه Manage Help Settings را انتخاب کنید. در صورتی که بار اولی است که از این گزینه استفاده می کنید از شما مسیر ذخیره سازی فایلهای آفلاین پرسیده خواهد شد. مسیر را با در نظر گرفتن اینکه ممکن است تا 3 گیگ فضا مورد نیاز باشد تایین کنید.

پس از آن می توانید از طریق گزینه «Choose online or local help» تعیین کنید که آیا از راهنمای آنلاین می خواهید استفاده کنید یا آفلاین. در صورت انتخاب گزینه آنلاین هیچ نیازی به نصب چیز دیگری نخواهید داشت و راهنمای از طریق سایت MSDN ماکروسافت نمایش داده خواهد شد.

در صورت انتخاب گزینه آفلاین سیستم راهنما از راهنماهای نصب شده استفاده خواهد کرد. پس نیاز خواهید داشت راهنماها را نصب کنید. نصب راهنمای آفلاین به سادگی از طریق نصب از دیسک نصب و یا دانلود امکان پذیر است. برای دانلود گزینه «Install content from online »  و برای نصب از دیسک گزینه «Install content from disk» را انتخاب کنید.

فایلهای راهنما در دی وی دی نصب موجود است و بهتر است بجای دانلود از آنها استفاده کنید. فایل نصب راهنما در مسیر DVD:\ProductDocumentation\HelpContentSetup.msha قرار دارد که باید از طریق گزینه Install content from disk اقدام کنید.

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

Help Library Manager

Help Library Manager

  • رفع مشکلات

پس از انجام عمل Repair برنامه نصب visual studio و یا به علت حذف ویا تغییر نا خواسته مسیر نصب فایلهای آفلاین سیستم راهنما به طور کل از کار می افتد و با اجرای مجدد Manage Help Settings جهت تغییر مسیر نصب و یا تغییر به وضعیت آنلاین، با خطا مواجه خواهید شد. در این وضعیت هیچ امکانی برای استفاده از راهنما نخواهید داشت. علاوه بر این در روشی که در ادامه توضیح می دم تقریبا هر مشکلی درباره نصب آفلاین راهنما رفع خواهد شد.

نمونه خطای سیستم راهنما

یکی از خطاهای سیستم راهنما

چند راه حل برای رفع این مشکل وجود دارد که ساده ترین آنها به این شکل است:

برنامه Regedit را باز کرده و به مسیر HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Help\v1.0  بروید. در آنجا مقدار LocalStore را پیدا کرده و پاک کنید. سپس مجددا گزینه Manage Help Settings را اجرا کنید تا مسیر نصب مجددا پرسیده شود. که می توانید در این حالت مسیر قبلی راهنماهای نصب شده را تعیین کنید.

  • برنامه کمکی H3Viewer

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

H3Viewer

H3Viewer

این برنامه کم حجم را می توانید از اینجا دریافت کنید (لینک دانلود در پایین صفحه): http://mshcmigrate.helpmvp.com/viewer

برنامه H3Viewer نیاز دارد تا سیستم راهنما در حالت آفلاین کار بکند، در این صورت می تواند راهنماهای نصب شده بر روی سیستم را لیست کند.

برای تنظیم مرورگر پیش فرض سیستم راهنما از طریق زیر منوی Options->Set default Viewer for MS HV 1.0 اقدام کنید. توجه کنید که برنامه باید با دسترسی administrator اجرا شده باشد.

پ.ن: در هر صورت وجود راهنمای اصلی نرم افزار لازم و ضروری به نظر می رسه گرچه ممکنه گوگل شما را سریع تر به نتیجه برسونه.





نمایش صحیح متون فارسی-انگلیسی در جهت چپ به راست

18 04 2010

خوشبختانه اکثر کامپوننت های کنونی از ویژگی راست به چپ متون پشتیبانی می کنند، اما همچنان کامپوننت هایی هستند که این ویژگی را که برای ما حیاتی است پشتیبانی نمی کنند. در چنین مواقعی ممکنه که نیاز داشته باشید که حتما از آن ابزار استفاده کنید، ولی همچنان مشکل متون فارسی همراه با متون انگلیسی را خواهید داشت.

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

PersianLeftToRightText

اصلاح متن فارسی برای نمایش صحیح در حالت چپ به راست

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

کد این کلاس همراه با پروژه نمونه از آدرس زیر قابل دریافت است.

دریافت کلاس PersianLeftToRight

ویرایش: همچنین نرم افزاری بر اساس همین کلاس نوشتم تا عمل تبدیل را بر روی فایل متنی انجام بده. این نرم افزار رو هم از اینجا دریافت کنید

دریافت برنامه PersianLeftToRightCorrection

پ.ن1: ممکن است که این کلاس برای برخی کاراکتر ها به درستی کار نکند، در صورت مشاهده این موارد لطفا آنها را گزارش کنید تا بررسی شوند.

پ.ن2: در متون چند خطی ترتیب نمایش به پایین به بالا تغییر پیدا می کند و این به خاطر از آخر به اول شدن متون فارسی هست.

موفق باشید.





انتقال اطلاعات بین دو کلاس مختلف

28 02 2010

کد کوتاهی که در ادامه خواهید دید، یکی از کاربردهای ویژگی Reflection دات نت رو در برنامه نویسی روزمره نشون میده. کاربرد این کد بسیار ساده است در عین حال می تواند خیلی مفید هم باشد.  با یک مثال نشان خواهم که چقدر می تواند در برنامه نویسی به کمکتون بیاد.

کاری که این کد انجام میده، کپی کردن مقادیر ویژگی های عمومی (public property) هست. به عبارت دقیق تر مقادیر ویزگی های یک شیئ را به مقادیر ویژگهای همنام از شیئ دیگر کپی میکند.

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

مسلما می توانید این کد رو ویرایش کنید تا با نیاز های شما سازگاری بیشتری داشته باشد، اما قبل این کار باید کد را ببینید:

public static void CopyPropertiesValue(object sourceModel, object destModel)
{
    Type sourceType = sourceModel.GetType();
    Type destType = destModel.GetType();

    foreach (PropertyInfo srcProp in sourceType.GetProperties())
    {
        PropertyInfo destProp = destType.GetProperty(srcProp.Name, BindingFlags.SetProperty | BindingFlags.Instance | BindingFlags.Public);
        if (destProp!=null)
        {
            try
            {
                destProp.SetValue(destModel, srcProp.GetValue(sourceModel, null), null);
            }
            catch { }
        }
    }
}

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

  • مثالی از کاربرد

شاید با مثال بهتر بتوان به کاربر این تابع پی برد.

ابتدا تعاریف کلاسهای مورد استفاده:

class Person
{
	public int PersonID { get; set; }
	public string PersonName { get; set; }
	public string PersonFamily { get; set; }
}
class Car
{
	public int CarID { get; set; }
	public int PersonID { get; set; }
	public string CarModel { get; set; }
}

/// <summary>
/// کلاسی از ترکیب آن دو کلاس
/// </summary>
class Person_Car
{
	public int CarID { get; set; }
	public int PersonID { get; set; }
	public string CarModel { get; set; }
	public string PersonName { get; set; }
	public string PersonFamily { get; set; }
}

در این نمونه کد مشاهده می کنید که مقادیر را می توانیم از کلاس Person_Car به دو کلاس بعدی انتقال دهیم:

public static void CopyModelTest()
{
	Person person = new Person();
	Car car = new Car();
	Person_Car pCar = new Person_Car()
	{
		CarID = 10,
		PersonID = 1,
		CarModel = "ژیان :=)" ,
		PersonFamily = "خلیل زاده",
		PersonName = "سالار"
	};

	CopyPropertiesValue(pCar, car);

	// کپی به کلاس Person
	CopyPropertiesValue(pCar, person);
}

این تابع خیلی به من کمک کرده، امیدوارم که برای شما هم مفید باشه.





بررسی وجود پیاده سازی محتویات MasterPage

25 10 2009

شاید در استفاده از MasterPage ها زمانی پیش آمده باشد که لازم شده وجود پیاده سازی یک ContentPlaceHolder را در صفحه خاص رو بررسی کنید. مثلا زمانی رو در نظر بگیرید که در صفحه خاصی نباید بلوک خلاصه محتویات صفحه یا لینکها نمایش داده شود و این کادر نیز در MasterPage پیاده سازی شده است.

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

خوشبختانه ویژگی داخلی و مخفی در کلاس MasterPage وجود دارد به نام ContentTemplates که لیستی از ContentPlaceHolder هست که توسط صفحه جاری پیاده سازی شده است. کاری که لازم است استفاده از قدرت Reflection دات نت هست تا به آن ویژگی دسترسی پیدا کنیم.

همراه با این باید ContentPlaceHolder برای وجود کنترل در داخلی خودش هم بررسی بشه. تابع زیر برای همین کار هست:

public static bool HasNonEmptyControls(ContentPlaceHolder cph)
{
    if (cph.Controls.Count == 0)
    {
        return false;
    }
    else if (cph.Controls.Count == 1)
    {
        LiteralControl c = cph.Controls[0] as LiteralControl;

        if (string.IsNullOrEmpty(c.Text) || IsWhiteSpace(c.Text))
            return false;
    }

    return true;
}

static bool IsWhiteSpace(string s)
{
    for (int i = 0; i < s.Length; i++)
        if (!char.IsWhiteSpace(s[i]))
            return false;

    return true;
}

در ادامه تابع اصلی منظور ما که وجود پیاده سازی از یک ContentPlaceHolder به خصوص رو بررسی خواهد کرد:

static readonly Type _masterType = typeof(MasterPage);
static readonly PropertyInfo _contentTemplatesProp = _masterType.GetProperty("ContentTemplates", BindingFlags.GetProperty | BindingFlags.NonPublic | BindingFlags.Instance);

public static bool HasContentPageContent(ContentPlaceHolder cph)
{
    IDictionary templates = null;
    MasterPage master = cph.Page.Master;

    while (templates == null && master != null)
    {
        templates = (IDictionary)_contentTemplatesProp.GetValue(master, null);
        master = master.Master;
    }

    if (templates == null)
        return false;

    bool isSpecified = false;

    foreach (string key in templates.Keys)
    {
        if (key == cph.ID)
        {
            isSpecified = true;

            break;
        }
    }

    return isSpecified;
}

همانطور که از کد مشخصه با بدست آوردن ویژگی ContentTemplates که یک لسیت دیکشنری است وجود ContentPlaceHolder مورد نظر رو بررسی می کنیم.

و سر انجام ترکیبی از این دو تابع جهت بدست آوردن نتیجه مطلوب:

public static bool HasContentOrControls(ContentPlaceHolder cph)
{
    return HasNonEmptyControls(cph) || HasContentPageContent(cph);
}

و تمام. به راحتی می توانید از این تابع استفاده کنید. مانند نمونه زیر:

<%if (HasContentOrControls(plhOptions)){ %>
<div id="options">
 <div>
 <h2>
 <asp:ContentPlaceHolder ID="plhOptionsTitle" runat="server" />
 </h2>
 <asp:ContentPlaceHolder ID="plhOptions" runat="server" />
 </div>
</div>
<%}%>

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

منبع

خوش باشید.