I guess that nobody can give you an acceptable answer because the question is not specific enough. But compared to higher programming languages you will be able to use your available memory much more efficient.

My point of view, There are instructions to store bytes (8 bits), half-words (16 bits), and double-words (64 bits). A process control block (PCB) is a data structure that contains information about a process. A PCB is created for each new process. When a process moves from one state to another, its PCB is moved with it. 

Marc Schmieger tell me i am right or wrong??????

You mean CPU programming for PC based programs? Sorry, that`s not my task, I use DSP`s for signal processing by pure assembler programming.

A process in an operating system is represented by a data structure known as a process control block (PCB) or process descriptor. The PCB contains important information about the specific process including

• The current state of the process i.e., whether it is ready, running, waiting, or whatever.
• Unique identification of the process in order to track "which is which" information.
• A pointer to parent process.
• Similarly, a pointer to child process (if it exists).
• The priority of process (a part of CPU scheduling information).
• Pointers to locate memory of processes.
• A register save area.
• The processor it is running on.

The PCB is a certain store that allows the operating systems to locate key information about a process. Thus, the PCB is the data structure that defines a process to the operating systems.

check the linux implementation of PCB it is open source OS, you can pull the STRUCT PCB and use sizeof() function to measure it, but may i ask to provide more details to obtain a specific answer

/*

* The Linux Process Control Block

* From: /usr/src/linux/include/linux/sched.h

* Kernel version 2.4.12

*/

struct task_struct {

/*

* offsets of these are hardcoded elsewhere - touch with care

*/

volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */

unsigned long flags; /* per process flags, defined below */

int sigpending;

mm_segment_t addr_limit; /* thread address space:

0-0xBFFFFFFF for user-thead

0-0xFFFFFFFF for kernel-thread

*/

struct exec_domain *exec_domain;

volatile long need_resched;

unsigned long ptrace;

int lock_depth; /* Lock depth */

/*

* offset 32 begins here on 32-bit platforms. We keep

* all fields in a single cacheline that are needed for

* the goodness() loop in schedule().

*/

long counter;

long nice;

unsigned long policy;

struct mm_struct *mm;

int has_cpu, processor;

unsigned long cpus_allowed;

/*

* (only the 'next' pointer fits into the cacheline, but

* that's just fine.)

*/

struct list_head run_list;

unsigned long sleep_time;

struct task_struct *next_task, *prev_task;

struct mm_struct *active_mm;

struct list_head local_pages;

unsigned int allocation_order, nr_local_pages;

/* task state */

struct linux_binfmt *binfmt;

int exit_code, exit_signal;

int pdeath_signal; /* The signal sent when the parent dies */

/* ??? */

unsigned long personality;

int did_exec:1;

pid_t pid;

pid_t pgrp;

pid_t tty_old_pgrp;

pid_t session;

pid_t tgid;

/* boolean value for session group leader */

int leader;

/*

* pointers to (original) parent process, youngest child, younger sibling,

* older sibling, respectively. (p->father can be replaced with

* p->p_pptr->pid)

*/

struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;

struct list_head thread_group;

/* PID hash table linkage. */

struct task_struct *pidhash_next;

struct task_struct **pidhash_pprev;

wait_queue_head_t wait_chldexit; /* for wait4() */

struct completion *vfork_done; /* for vfork() */

unsigned long rt_priority;

unsigned long it_real_value, it_prof_value, it_virt_value;

unsigned long it_real_incr, it_prof_incr, it_virt_incr;

struct timer_list real_timer;

struct tms times;

unsigned long start_time;

long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS];

/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */

unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;

int swappable:1;

/* process credentials */

uid_t uid,euid,suid,fsuid;

gid_t gid,egid,sgid,fsgid;

int ngroups;

gid_t groups[NGROUPS];

kernel_cap_t cap_effective, cap_inheritable, cap_permitted;

int keep_capabilities:1;

struct user_struct *user;

/* limits */

struct rlimit rlim[RLIM_NLIMITS];

unsigned short used_math;

char comm[16];

/* file system info */

int link_count, total_link_count;

struct tty_struct *tty; /* NULL if no tty */

unsigned int locks; /* How many file locks are being held */

/* ipc stuff */

struct sem_undo *semundo;

struct sem_queue *semsleeping;

/* CPU-specific state of this task */

struct thread_struct thread;

/* filesystem information */

struct fs_struct *fs;

/* open file information */

struct files_struct *files;

/* signal handlers */

spinlock_t sigmask_lock; /* Protects signal and blocked */

struct signal_struct *sig;

sigset_t blocked;

struct sigpending pending;

unsigned long sas_ss_sp;

size_t sas_ss_size;

int (*notifier)(void *priv);

void *notifier_data;

sigset_t *notifier_mask;

/* Thread group tracking */

u32 parent_exec_id;

u32 self_exec_id;

/* Protection of (de-)allocation: mm, files, fs, tty */

spinlock_t alloc_lock;

};

have a nice day