How does embedded linux boot up differ from a traditional embedded system?

A traditional embedded system boots from flash memory and code runs from flash memory. Usually application isn’t copied to RAM, only read/write variables are copied to RAM.
Does system running embedded Linux execute from RAM?

A typical embedded Linux evaluation board running some Linux distribution boots from SD card. I believe entire kernel code, rwdata, rodata, init, bss, etc. is copied to RAM and code execution occurs in RAM. Is that correct?

I need to know what size DRAM I need for my embedded Linux system? If Linux distribution takes up 3GB in SD card. Then, does this mean I need 3GB DRAM?

It depends...

If your target system only runs some limited subset of program, no, of course
not. What is taking up the 3GB on the SD card are things like the usuall
"zillion" utilities, libraries, and so on. Also, an embedded Linux appliance
(like your router or Blu-Ray player), is going to use BusyBox rather than have
a /bin and /usr/bin populated with all the usually little programs (ls, cp,
mv, rm, etc.). Instead, /bin, /sbin, /usr/bin and /usr/sbin will have links
to BusyBox. Basically, it is just like a Linux boot init "ramdisk" that never
bothers to mount a real "root" file system and continues to a full multi-user
boot with all the trimmings.

Next time you fire up your Beagle Bone, use the free and top commands to have
a look at what is running and how (RAM) memory is being used. For example, my
Raspberry Pi fruitloops is currently using just under 1 GB of RAM, running
about 100 processes:

Tasks: 109 total, 1 running, 60 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.3 sy, 0.0 ni, 99.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem: 948308 total, 908924 used, 39384 free, 142516 buffers
KiB Swap: 102396 total, 21248 used, 81148 free. 138932 cached Mem

It is also using 21GB of a 32GB SD card. This is Raspbian, and includes a
pretty typical Linux multi-user system, eg systemd, ssh server, X11, a
compilete native G++ toolchain and libraries, with multiple cross-build G++
toolchain and libraries, for Arduino (arm, avr, xtensa) and OpenMRN (arm),
along with a full LaTeX install, Doxygen, etc. -- this is my general purpose
build box for both native Raspbian (and also Beagle Debian targets), and for
various little MCUs: Avr, Arm (samd), and esp32 Arduino supported, and various
ARM-based MCUs supported by OpenMRN.

On Mon, 29 Jul 2019 05:56:00 -0700 (PDT), Jani
<amern2k16@gmail.com> declaimed the
following:

A traditional embedded system boots from flash memory and code runs from
flash memory. Usually application isn't copied to RAM, only read/write
variables are copied to RAM.

  Define "traditional embedded system" <G>

  In the readily available market, what you describe above falls into the
Arduino, Tiva-C, Adafruit Metro, Parallax Propeller cards -- which are
classed as "microCONTROLLER" boards. The closest they get to having an OS
might be applications using something like FreeRTOS (or TI-RTOS for the
Tiva-C) -- ie: the application /is/ the OS. The Flash memory on such
systems is directly mapped into the processor address space along with the
RAM and any memory-mapped I/O devices/ports.

Does system running embedded Linux execute from RAM?

  Once you specify Linux, you mostly are talking "microCOMPUTER" with a
full up OS and related file system, "ad-hoc" process creation (in an RTOS,
all processes tend to be predefined and created on start-up), etc. Any
Flash memory tends to be configured as an I/O device and is part of the
file-system, not part of the processor memory address space.

  This does not preclude designing a board in which some of the processor
address space is Flash memory. It may even be possible to build a Linux
kernel (or whatever that binary file that is used during booting -- I'm not
an OS developer) image that can be stored in flash and directly jumped to
during booting (it would probably offer much faster start-up if the boot
load just has to set up processor registers/zero RAM and can jump directly
into the OS -- rather than copying a core image file into RAM and jumping
to it). I have seen a card which did have memory-mapped Flash (I had to
port benchmarks to it some years ago, and the benchmarks ran as pure
start-up code from Flash).

  BeagleBone and Raspberry-PI, however, do not have memory-mapped Flash;
they run from RAM and load the core image from a defined file-system on I/O
device Flash.

I need to know what size DRAM I need for my embedded Linux system? If
Linux distribution takes up 3GB in SD card. Then, does this mean I need
3GB DRAM?

  BBB has a 4GB eMMC (or use SDHC up to 32GB) but only 512MB of RAM. The
R-Pi3B doesn't have on-board eMMC, so uses SDHC up to 32GB, and has 1GB of
RAM (it also has a quad-core processor). The latest R-Pi4B can be had with
1, 2, or 4GB of RAM.

  Also take into account that, if you have external storage (disk), these
systems can be configured with a swap partition/file and could move idle
data/code out to swap. OTOH; once you start swapping you lose much of any
realtime capabilities -- you could be caught with swapping latency if, say,
a very rare interrupt occurs and the handler is not in core.

Jani:
Here’s what I use with my students for the Beagle: BeagleBoard-exercises/04-1 Booting.pdf at master · MarkAYoder/BeagleBoard-exercises · GitHub

Slide 16 shows the overall picture.

–Mark

On Mon, 29 Jul 2019 05:56:00 -0700 (PDT), Jani
<amern2k16@gmail.com> declaimed the
following:

>A traditional embedded system boots from flash memory and code runs from
>flash memory. Usually application isn't copied to RAM, only read/write
>variables are copied to RAM.

  Define "traditional embedded system" <G>

  In the readily available market, what you describe above falls into the
Arduino, Tiva-C, Adafruit Metro, Parallax Propeller cards -- which are
classed as "microCONTROLLER" boards. The closest they get to having an OS
might be applications using something like FreeRTOS (or TI-RTOS for the
Tiva-C) -- ie: the application /is/ the OS. The Flash memory on such
systems is directly mapped into the processor address space along with the
RAM and any memory-mapped I/O devices/ports.

>Does system running embedded Linux execute from RAM?
>

  Once you specify Linux, you mostly are talking "microCOMPUTER" with a
full up OS and related file system, "ad-hoc" process creation (in an RTOS,
all processes tend to be predefined and created on start-up), etc. Any
Flash memory tends to be configured as an I/O device and is part of the
file-system, not part of the processor memory address space.

I think the OP is talking about "appliance" systems. This would include most
home Internet Routers, it would include Internet-ready Sony Blu-Ray players
(go visit the System Copyright screen from the Setup Menu: it is GPL, BusyBox
is mentioned, etc.). These "embedded Linux" systems run a stripped down O/S.
It really is Linux and do have a flash boot ROM (I expect probably much like
the BBB's eMMC). These "appliance" systems are somewhere between the
Arduino-ish MCUs and the BBB and Raspberry Pi type machines.

use the free and top commands

memory_usage.PNG

Memory information during boot up is as follows:

memory.PNG

top command vs. memory information during boot up. I believe memory information during boot up should be used to determine what size DRAM is needed?

Define “traditional embedded system”
your definition is correct!