By: Bryan Dixon

prettybadelyngeΛογισμικό & κατασκευή λογ/κού

18 Νοε 2013 (πριν από 4 χρόνια και 6 μήνες)

80 εμφανίσεις

By: Bryan Dixon


Explicit Memory Management

grained control over assembly level data


Lacks any sort of structure to ensure type safety
and safe memory usage.


Lacks performance and explicit memory/low level
details needed.

Create a new language with these language
features in mind

Check existing C code at compile/runtime for
possible type/memory issues than can arise.

Create an extension of the C language to add
these extra languages features/checks

Similar to a compiler extension to enforce
ANSI C style

Can formally check statically at compile time
for type safety

Add dynamic runtime checks to check for
memory safety at runtime.

Doesn’t require you to change legacy code.

A type of compiler extension for type safety

Does its checking by adding runtime
extensions to existing code to ensure safety

Requires almost no changes in existing code

No formal soundness to the safety provided

540% performance overhead

Unlike dynamic type safety checking like
SafeC, also does static type checking at
compile time, limiting the pointers/types that
need to be monitored at runtime

Some drawbacks on the safety that CCured
forces on memory management that make it
lack some explicit memory management
functionality desired as a systems level

150% performance overhead

Deputy/Ivy: From Berkley and are similar to
the other two though slightly different

May require new includes in legacy code

Likely similar performance overhead of
, as they perform static type analysis
or use type annotations to reduce the need to
do all the type checks at
run time.

Similar to C syntax but new syntax to better
support type safety

Cyclone has added support for type
safety in
threaded processes.

Slight modifications to existing code possibly
needed, though most code will not need

150% performance improvement

Best solution if you wanted to rewrite
everything from scratch

You can’t make use of any/all legacy code

Likely to be the best solution for

Best example is Vault, vault currently unsafe
in multithreaded processes.

Likely similar performance to that of Cyclone

No perfect solution currently, lots of
overhead and may require changes to
existing code to make it type safe or even
completely rewriting code to a new language

If I had to make a choice of current options
would choose Cyclone as it offers better
performance with the least overhead and
offers support in a recent release for