- Atomic Number: 28 Atomic Mass: 58.6934 amu Melting Point: 1453.0 °C (1726.15 K, 2647.4 °F) Boiling Point: 2732.0 °C (3005.15 K, 4949.6 °F) Number of Protons/Electrons: 28 Number of Neutrons: 31 Classification: Transition Metal Crystal Structure: Cubic Density @ 293 K: 8.902 g/cm 3 Color: white Atomic Structure.
- For example, the atomic number of sodium is 11. This implies that the nucleus of the sodium atom contains 11 protons and is surrounded by a total of 11 electrons. Since the atomic number of an atom is equal to the number of electrons it contains, the electronic configuration of the element can be determined just by knowing its atomic number.
Click a column header, such as Name, to sort the table by that item.
SEENotes at the bottom of the Table.
|5||10.811||Boron||B||2,300||2,550||2.34||1808||13||[He] 2s2 2p1||8.30|
|6||12.011||Carbon||C||3,500||4,827||2.26||0.09||ancient||14||[He] 2s2 2p2||11.26|
|7||14.007||Nitrogen||N||-210||-196||1.25||1772||15||[He] 2s2 2p3||14.53|
|8||15.999||Oxygen||O||-218||-183||1.43||46.71||1774||16||[He] 2s2 2p4||13.62|
|9||18.998||Fluorine||F||-220||-188||1.70||0.03||1886||17||[He] 2s2 2p5||17.42|
|10||20.180||Neon||Ne||-249||-246||0.90||1898||18||[He] 2s2 2p6||21.56|
|13||26.982||Aluminum||Al||660||2,467||2.70||8.07||1825||13||[Ne] 3s2 3p1||5.99|
|14||28.086||Silicon||Si||1,410||2,355||2.33||27.69||1824||14||[Ne] 3s2 3p2||8.15|
|15||30.974||Phosphorus||P||44||280||1.82||0.13||1669||15||[Ne] 3s2 3p3||10.49|
|16||32.065||Sulfur||S||113||445||2.07||0.05||ancient||16||[Ne] 3s2 3p4||10.36|
|17||35.453||Chlorine||Cl||-101||-35||3.21||0.05||1774||17||[Ne] 3s2 3p5||12.97|
|18||39.948||Argon||Ar||-189||-186||1.78||1894||18||[Ne] 3s2 3p6||15.76|
|21||44.956||Scandium||Sc||1,539||2,832||2.99||1879||3||[Ar] 3d1 4s2||6.56|
|22||47.867||Titanium||Ti||1,660||3,287||4.54||0.62||1791||4||[Ar] 3d2 4s2||6.83|
|23||50.942||Vanadium||V||1,890||3,380||6.11||1830||5||[Ar] 3d3 4s2||6.75|
|24||51.996||Chromium||Cr||1,857||2,672||7.19||0.04||1797||6||[Ar] 3d5 4s1||6.77|
|25||54.938||Manganese||Mn||1,245||1,962||7.43||0.09||1774||7||[Ar] 3d5 4s2||7.43|
|26||55.845||Iron||Fe||1,535||2,750||7.87||5.05||ancient||8||[Ar] 3d6 4s2||7.90|
|27||58.933||Cobalt||Co||1,495||2,870||8.90||1735||9||[Ar] 3d7 4s2||7.88|
|28||58.693||Nickel||Ni||1,453||2,732||8.90||0.02||1751||10||[Ar] 3d8 4s2||7.64|
|29||63.546||Copper||Cu||1,083||2,567||8.96||ancient||11||[Ar] 3d10 4s1||7.73|
|30||65.390||Zinc||Zn||420||907||7.13||ancient||12||[Ar] 3d10 4s2||9.39|
|31||69.723||Gallium||Ga||30||2,403||5.91||1875||13||[Ar] 3d10 4s2 4p1||6.00|
|32||72.640||Germanium||Ge||937||2,830||5.32||1886||14||[Ar] 3d10 4s2 4p2||7.90|
|33||74.922||Arsenic||As||81||613||5.72||ancient||15||[Ar] 3d10 4s2 4p3||9.79|
|34||78.960||Selenium||Se||217||685||4.79||1817||16||[Ar] 3d10 4s2 4p4||9.75|
|35||79.904||Bromine||Br||-7||59||3.12||1826||17||[Ar] 3d10 4s2 4p5||11.81|
|36||83.800||Krypton||Kr||-157||-153||3.75||1898||18||[Ar] 3d10 4s2 4p6||14.00|
|39||88.906||Yttrium||Y||1,523||3,337||4.47||1794||3||[Kr] 4d1 5s2||6.22|
|40||91.224||Zirconium||Zr||1,852||4,377||6.51||0.03||1789||4||[Kr] 4d2 5s2||6.63|
|41||92.906||Niobium||Nb||2,468||4,927||8.57||1801||5||[Kr] 4d4 5s1||6.76|
|42||95.940||Molybdenum||Mo||2,617||4,612||10.22||1781||6||[Kr] 4d5 5s1||7.09|
|43||*||98.000||Technetium||Tc||2,200||4,877||11.50||1937||7||[Kr] 4d5 5s2||7.28|
|44||101.070||Ruthenium||Ru||2,250||3,900||12.37||1844||8||[Kr] 4d7 5s1||7.36|
|45||102.906||Rhodium||Rh||1,966||3,727||12.41||1803||9||[Kr] 4d8 5s1||7.46|
|47||107.868||Silver||Ag||962||2,212||10.50||ancient||11||[Kr] 4d10 5s1||7.58|
|48||112.411||Cadmium||Cd||321||765||8.65||1817||12||[Kr] 4d10 5s2||8.99|
|49||114.818||Indium||In||157||2,000||7.31||1863||13||[Kr] 4d10 5s2 5p1||5.79|
|50||118.710||Tin||Sn||232||2,270||7.31||ancient||14||[Kr] 4d10 5s2 5p2||7.34|
|51||121.760||Antimony||Sb||630||1,750||6.68||ancient||15||[Kr] 4d10 5s2 5p3||8.61|
|52||127.600||Tellurium||Te||449||990||6.24||1783||16||[Kr] 4d10 5s2 5p4||9.01|
|53||126.905||Iodine||I||114||184||4.93||1811||17||[Kr] 4d10 5s2 5p5||10.45|
|54||131.293||Xenon||Xe||-112||-108||5.90||1898||18||[Kr] 4d10 5s2 5p6||12.13|
|57||138.906||Lanthanum||La||920||3,469||6.15||1839||3||[Xe] 5d1 6s2||5.58|
|58||140.116||Cerium||Ce||795||3,257||6.77||1803||101||[Xe] 4f1 5d1 6s2||5.54|
|59||140.908||Praseodymium||Pr||935||3,127||6.77||1885||101||[Xe] 4f3 6s2||5.47|
|60||144.240||Neodymium||Nd||1,010||3,127||7.01||1885||101||[Xe] 4f4 6s2||5.53|
|61||*||145.000||Promethium||Pm||1,100||3,000||7.30||1945||101||[Xe] 4f5 6s2||5.58|
|62||150.360||Samarium||Sm||1,072||1,900||7.52||1879||101||[Xe] 4f6 6s2||5.64|
|63||151.964||Europium||Eu||822||1,597||5.24||1901||101||[Xe] 4f7 6s2||5.67|
|64||157.250||Gadolinium||Gd||1,311||3,233||7.90||1880||101||[Xe] 4f7 5d1 6s2||6.15|
|65||158.925||Terbium||Tb||1,360||3,041||8.23||1843||101||[Xe] 4f9 6s2||5.86|
|66||162.500||Dysprosium||Dy||1,412||2,562||8.55||1886||101||[Xe] 4f10 6s2||5.94|
|67||164.930||Holmium||Ho||1,470||2,720||8.80||1867||101||[Xe] 4f11 6s2||6.02|
|68||167.259||Erbium||Er||1,522||2,510||9.07||1842||101||[Xe] 4f12 6s2||6.11|
|69||168.934||Thulium||Tm||1,545||1,727||9.32||1879||101||[Xe] 4f13 6s2||6.18|
|70||173.040||Ytterbium||Yb||824||1,466||6.90||1878||101||[Xe] 4f14 6s2||6.25|
|71||174.967||Lutetium||Lu||1,656||3,315||9.84||1907||101||[Xe] 4f14 5d1 6s2||5.43|
|72||178.490||Hafnium||Hf||2,150||5,400||13.31||1923||4||[Xe] 4f14 5d2 6s2||6.83|
|73||180.948||Tantalum||Ta||2,996||5,425||16.65||1802||5||[Xe] 4f14 5d3 6s2||7.55|
|74||183.840||Tungsten||W||3,410||5,660||19.35||1783||6||[Xe] 4f14 5d4 6s2||7.86|
|75||186.207||Rhenium||Re||3,180||5,627||21.04||1925||7||[Xe] 4f14 5d5 6s2||7.83|
|76||190.230||Osmium||Os||3,045||5,027||22.60||1803||8||[Xe] 4f14 5d6 6s2||8.44|
|77||192.217||Iridium||Ir||2,410||4,527||22.40||1803||9||[Xe] 4f14 5d7 6s2||8.97|
|78||195.078||Platinum||Pt||1,772||3,827||21.45||1735||10||[Xe] 4f14 5d9 6s1||8.96|
|79||196.967||Gold||Au||1,064||2,807||19.32||ancient||11||[Xe] 4f14 5d10 6s1||9.23|
|80||200.590||Mercury||Hg||-39||357||13.55||ancient||12||[Xe] 4f14 5d10 6s2||10.44|
|81||204.383||Thallium||Tl||303||1,457||11.85||1861||13||[Xe] 4f14 5d10 6s2 6p1||6.11|
|82||207.200||Lead||Pb||327||1,740||11.35||ancient||14||[Xe] 4f14 5d10 6s2 6p2||7.42|
|83||208.980||Bismuth||Bi||271||1,560||9.75||ancient||15||[Xe] 4f14 5d10 6s2 6p3||7.29|
|84||*||209.000||Polonium||Po||254||962||9.30||1898||16||[Xe] 4f14 5d10 6s2 6p4||8.42|
|85||*||210.000||Astatine||At||302||337||0.00||1940||17||[Xe] 4f14 5d10 6s2 6p5||9.30|
|86||*||222.000||Radon||Rn||-71||-62||9.73||1900||18||[Xe] 4f14 5d10 6s2 6p6||10.75|
|89||*||227.000||Actinium||Ac||1,050||3,200||10.07||1899||3||[Rn] 6d1 7s2||5.17|
|90||232.038||Thorium||Th||1,750||4,790||11.72||1829||102||[Rn] 6d2 7s2||6.31|
|91||231.036||Protactinium||Pa||1,568||0||15.40||1913||102||[Rn] 5f2 6d1 7s2||5.89|
|92||238.029||Uranium||U||1,132||3,818||18.95||1789||102||[Rn] 5f3 6d1 7s2||6.19|
|93||*||237.000||Neptunium||Np||640||3,902||20.20||1940||102||[Rn] 5f4 6d1 7s2||6.27|
|94||*||244.000||Plutonium||Pu||640||3,235||19.84||1940||102||[Rn] 5f6 7s2||6.03|
|95||*||243.000||Americium||Am||994||2,607||13.67||1944||102||[Rn] 5f7 7s2||5.97|
Atomic number The number of protons in the nucleus of an atom. In electrically neutral atoms, this number is also equal to the number of electrons orbiting about the atom's nucleus. The atomic number of an element determines its position in the Periodic Table.
• Density of elements with boiling points below 0°C is given in g/l. In a sorted list, these elements are shown before other elements that have boiling points >0°C.
• Earth crust composition average values are from a report by F. W. Clarke and H. S. Washington, 1924. Elemental composition of crustal rocks differ between different localities (see article).
• Group: There are only 18 groups in the periodic table that constitute the columns of the table. Lanthanoids and Actinoids are numbered as 101 and 102 to separate them in sorting by group.
• The elements marked with an asterisk (in the 2nd column) have no stable nuclides. For these elements the weight value shown represents the mass number of the longest-lived isotope of the element.
Abbreviations and Definitions:
No. - Atomic Number; M.P. - melting point; B.P. - boiling point
Atomic number: The number of protons in an atom. Each element is uniquely defined by its atomic number.
Atomic mass: The mass of an atom is primarily determined by the number of protons and neutrons in its nucleus. Atomic mass is measured in Atomic Mass Units (amu) which are scaled relative to carbon, 12C, that is taken as a standard element with an atomic mass of 12. This isotope of carbon has 6 protons and 6 neutrons. Thus, each proton and neutron has a mass of about 1 amu.
Isotope: Atoms of the same element with the same atomic number, but different number of neutrons. Isotope of an element is defined by the sum of the number of protons and neutrons in its nucleus. Elements have more than one isotope with varying numbers of neutrons. For example, there are two common isotopes of carbon, 12C and 13C which have 6 and 7 neutrons respectively. The abundances of different isotopes of elements vary in nature depending on the source of materials. For relative abundances of isotopes in nature see reference on Atomic Weights and Isotopic Compositions.
Atomic weight: Atomic weight values represent weighted average of the masses of all naturally occurring isotopes of an element. The values shown here are based on the IUPAC Commission determinations (Pure Appl. Chem. 73:667-683, 2001). The elements marked with an asterisk have no stable nuclides. For these elements the weight value shown represents the mass number of the longest-lived isotope of the element.
Electron configuration: See next page for explanation of electron configuration of atoms.
Ionization energy (IE): The energy required to remove the outermost electron from an atom or a positive ion in its ground level. The table lists only the first IE in eV units. To convert to kJ/mol multiply by 96.4869. Reference: NIST Reference Table on Ground states and ionization energies for the neutral atoms. IE decreases going down a column of the periodic table, and increases from left to right in a row. Thus, alkali metals have the lowest IE in a period and Rare gases have the highest.
Other resources related to the Periodic Table
- Chemical Evolution of the Universe
Much has already been written about atomic operations on the web, usually with a focus on atomic read-modify-write (RMW) operations. However, those aren’t the only kinds of atomic operations. There are also atomic loads and stores, which are equally important. In this post, I’ll compare atomic loads and stores to their non-atomic counterparts at both the processor level and the C/C++ language level. Along the way, we’ll clarify the C++11 concept of a “data race”.
An operation acting on shared memory is atomic if it completes in a single step relative to other threads. When an atomic store is performed on a shared variable, no other thread can observe the modification half-complete. When an atomic load is performed on a shared variable, it reads the entire value as it appeared at a single moment in time. Non-atomic loads and stores do not make those guarantees.
Without those guarantees, lock-free programming would be impossible, since you could never let different threads manipulate a shared variable at the same time. We can formulate it as a rule:
Any time two threads operate on a shared variable concurrently, and one of those operations performs a write, both threads must use atomic operations.
If you violate this rule, and either thread uses a non-atomic operation, you’ll have what the C++11 standard refers to as a data race (not to be confused with Java’s concept of a data race, which is different, or the more general race condition). The C++11 standard doesn’t tell you why data races are bad; only that if you have one, “undefined behavior” will result (§1.10.21). The real reason why such data races are bad is actually quite simple: They result in torn reads and torn writes.
A memory operation can be non-atomic because it uses multiple CPU instructions, non-atomic even when using a single CPU instruction, or non-atomic because you’re writing portable code and you simply can’t make the assumption. Let’s look at a few examples.
Non-Atomic Due to Multiple CPU Instructions
Suppose you have a 64-bit global variable, initially zero.
At some point, you assign a 64-bit value to this variable.
When you compile this function for 32-bit x86 using GCC, it generates the following machine code.
As you can see, the compiler implemented the 64-bit assignment using two separate machine instructions. The first instruction sets the lower 32 bits to
0x00000002, and the second sets the upper 32 bits to
0x00000001. Clearly, this assignment operation is not atomic. If
sharedValue is accessed concurrently by different threads, several things can now go wrong:
- If a thread calling
storeValueis preempted between the two machine instructions, it will leave the value of
0x0000000000000002in memory – a torn write. At this point, if another thread reads
sharedValue, it will receive this completely bogus value which nobody intended to store.
- Even worse, if a thread is preempted between the two instructions, and another thread modifies
sharedValuebefore the first thread resumes, it will result in a permanently torn write: the upper 32 bits from one thread, the lower 32 bits from another.
- On multicore devices, it isn’t even necessary to preempt one of the threads to have a torn write. When a thread calls
storeValue, any thread executing on a different core could read
sharedValueat a moment when only half the change is visible.
Reading concurrently from
sharedValue brings its own set of problems:
Here too, the compiler has implemented the load operation using two machine instructions: The first reads the lower 32 bits into
eax, and the second reads the upper 32 bits into
edx. In this case, if a concurrent store to
sharedValue becomes visible between the two instructions, it will result in a torn read – even if the concurrent store was atomic.
These problems are not just theoretical. Mintomic’s test suite includes a test case called
test_load_store_64_fail, in which one thread stores a bunch of 64-bit values to a single variable using a plain assignment operator, while another thread repeatedly performs a plain load from the same variable, validating each result. On a multicore x86, this test fails consistently, as expected.
Non-Atomic CPU Instructions
A memory operation can be non-atomic even when performed by a single CPU instruction. For example, the ARMv7 instruction set includes the
strd instruction, which stores the contents of two 32-bit source registers to a single 64-bit value in memory.
On some ARMv7 processors, this instruction is not atomic. When the processor sees this instruction, it actually performs two separate 32-bit stores under the hood (§A3.5.3). Once again, another thread running on a separate core has the possibility of observing a torn write. Interestingly, a torn write is even possible on a single-core device: A system interrupt – say, for a scheduled thread context switch – can actually occur between the two internal 32-bit stores! In this case, when the thread resumes from the interrupt, it will restart the
strd instruction all over again.
As another example, it’s well-known that on x86, a 32-bit
mov instruction is atomic if the memory operand is naturally aligned, but non-atomic otherwise. In other words, atomicity is only guaranteed when the 32-bit integer is located at an address which is an exact multiple of 4. Mintomic comes with another test case,
test_load_store_32_fail, which verifies this guarantee. As it’s written, this test always succeeds on x86, but if you modify the test to force
sharedInt to certain unaligned addresses, it will fail. On my Core 2 Quad Q6600, the test fails when
sharedInt crosses a cache line boundary:
Those are enough processor-specific details for now. Let’s look at atomicity at the C/C++ language level.
All C/C++ Operations Are Presumed Non-Atomic
In C and C++, every operation is presumed non-atomic unless otherwise specified by the compiler or hardware vendor – even plain 32-bit integer assignment.
The language standards have nothing to say about atomicity in this case. Maybe integer assignment is atomic, maybe it isn’t. Since non-atomic operations don’t make any guarantees, plain integer assignment in C is non-atomic by definition.
In practice, we usually know more about our target platforms than that. For example, it’s common knowledge that on all modern x86, x64, Itanium, SPARC, ARM and PowerPC processors, plain 32-bit integer assignment is atomic as long as the target variable is naturally aligned. You can verify it by consulting your processor manual and/or compiler documentation. In the games industry, I can tell you that a lot of 32-bit integer assignments rely on this particular guarantee.
Nonetheless, when writing truly portable C and C++, there’s a long-standing tradition of pretending that we don’t know anything more than what the language standards tell us. Portable C and C++ is designed to run on every possible computing device past, present and imaginary. Personally, I like to imagine a machine where memory can only be changed by mixing it up first:
On such a machine, you definitely wouldn’t want to perform a concurrent read at the same time as a plain assignment; you could end up reading a completely random value.
In C++11, there is finally a way to perform truly portable atomic loads and stores: the C++11 atomic library. Atomic loads and stores performed using the C++11 atomic library would even work on the imaginary computer above – even if it means the C++11 atomic library must secretly lock a mutex to make each operation atomic. There’s also the Mintomic library which I released last month, which doesn’t support as many platforms, but works on several older compilers, is hand-optimized and is guaranteed to be lock-free.
Relaxed Atomic Operations
Let’s return to the original
sharedValue example from earlier in this post. We’ll rewrite it using Mintomic so that all operations are performed atomically on every platform Mintomic supports. First, we must declare
sharedValue as one of Mintomic’s atomic data types.
mint_atomic64_t type guarantees correct memory alignment for atomic access on each platform. This is important because, for example, the GCC 4.2 compiler for ARM bundled with Xcode 3.2.5 doesn’t guarantee that plain
uint64_t will be 8-byte aligned.
storeValue, instead of performing a plain, non-atomic assignment, we must call
loadValue, we call
Bad kitty camp daze pdf free download full. Using C++11’s terminology, these functions are now data race-free. When executing concurrently, there is absolutely no possibility of a torn read or write, whether the code runs on ARMv6/ARMv7 (Thumb or ARM mode), x86, x64 or PowerPC. If you’re curious how
mint_store_64_relaxed actually work, both functions expand to an inline
cmpxchg8b instruction on x86; for other platforms, consult Mintomic’s implementation.
Here’s the exact same thing written in C++11 instead:
You’ll notice that both the Mintomic and C++11 examples use relaxed atomics, as evidenced by the
_relaxed suffix on various identifiers. The
_relaxed suffix is a reminder that few guarantees are made about memory ordering.
In particular, it is still legal for the memory effects of a relaxed atomic operation to be reordered with respect to instructions which follow or precede it in program order, either due to compiler reordering or memory reordering on the processor itself. The compiler could even perform optimizations on redundant relaxed atomic operations, just as with non-atomic operations. In all cases, the operation remains atomic.
Atomic Nomad Blackeye
When manipulating shared memory concurrently, I think it’s good practice to always use Mintomic or C++11 atomic library functions, even in cases where you know that a plain load or store would already be atomic on your target platform. An atomic library function serves as a reminder that elsewhere, the variable is the target of concurrent data access.
Atomic Number Definition Chemistry
Hopefully, it’s now a bit more clear why the World’s Simplest Lock-Free Hash Table uses Mintomic library functions to manipulate shared memory concurrently from different threads.