Subject: Group: Get 250k coverage - Exam not needed

From: Term Life Milestone (Support) <[email-masked]>
Date: Thu, 10 Jul 2014 08:10:45 -0700

Hello Atompub-archive,

If you think about it for a minute, you insure everything that's significant in your life; why not insure yourself? Life coverage provides you peace of mind and can provide your family with financial stability and security when it matters most.

No exam necessary | 250k Coverage for 15/month|
http://www.transportbuy.com/coverage-plc-67567.pln4

A life policy gives you and your loved ones protection from the unexpected. You know that if something happens to you, family will have the financial protection they will need down the road.

Thank You.

-- This is from BBK us coverage -- Eight One One Robin Drive. -- Pittsburgh -- PA 15220
-- To simple end-ad messages go to http://www.transportbuy.com/nnt.g --

/
/
/
/
/
/
/
/
/
/
Upon comparing test code with Sam, I determined that we are both right
However, about different things:

Accessing memory (reading and writing) is just as fast wherever it is - stack, global or heap.
Allocating it, however, is fastest on stack and slowest on heap.
It goes like this: stack < global < heap. (allocation time)

I strongly advise being careful with this, though.
I recommend the following:

When you need to create many arrays often, using the stack can be an enormous improvement.
If you can recycle an array, do so whenever you can The heap is the best place for long-term object storage.
(Note: 1. only applies to value types; reference types will be allocated on the heap and the benefit will be reduced to 0)

To answer the question itself: I have not encountered any problem at all with any large-stack test.
I believe the only possible problem(s) may come from memory paging.
If the stack needs to be continuous, you may get OutOfMemoryExceptions (or StackOverflowExceptions?) because whatever block needs to be allocated next may be taken. If the stack is paged, there should be no issue to your application.

However, no matter where you allocate your array, it needs continuous memory, so, unless a thread's stack can be moved, it's the most error-prone location to allocate it.

The section below is my initial answer. It is kept only for reference.

My test indicates the stack-allocated memory and global memory is at least 15% slower than (takes 120% the time of) heap-allocated memory for usage in arrays

This is my test code, and this is a sample output:

Stack-allocated array time: 00:00:00.2224429
Globally-allocated array time: 00:00:00.2206767
Heap-allocated array time: 00:00:00.1842670
------------------------------------------

Thanks.