Section 13-08-24: Fill & Download for Free

I show you a simple example how it’s done. Very simple. First our source in C:#include <stdio.h> #include <stdlib.h>  unsigned long fib(int f){  unsigned long n[3]={1,1,1};   for(int i=2; i<f; i++){  n[2]=n[1];  n[1]=n[0];  n[0]=n[1]+n[2];  }  return n[0]; }   int main(int argc, char *argv[]){  if(argc!=2) {  printf(“use: fib <num>\n”);  exit(0);  }  printf(“%lu\n”, fib(atoi(argv[1]))); } This is just the typical fibonacci and I have chosen this, to show how it is done, not because it’s a very sensible thing to optimize fibonacci. But anyway.We compile it withcc -S -O1 -o optimize.s optimize.c I only optimize “1” because from 2 on it will inline the code and do pretty much the work we are doing. And that’s not helping here. The “-S” flag tells the compiler to give us the assembly.We get the assembly output optimize.s:.file “optimize.c”  .text  .globl fib  .type fib, @function fib: .LFB38:  .cfi_startproc  cmpl $2, %edi  jle .L4  movl $1, %ecx  movl $1, %esi  movl $2, %edx  jmp .L3 .L5:  movq %rax, %rcx .L3:  leaq (%rsi,%rcx), %rax  addl $1, %edx  movq %rcx, %rsi  cmpl %edx, %edi  jne .L5  rep ret .L4:  movl $1, %eax  ret  .cfi_endproc .LFE38:  .size fib, .-fib  .section .rodata.str1.1,“aMS”,@progbits,1 .LC0:  .string “use: fib <num>” .LC1:  .string “%lu\n”  .text  .globl main  .type main, @function main: .LFB39:  .cfi_startproc  subq $8, %rsp  .cfi_def_cfa_offset 16  cmpl $2, %edi  je .L7  movl $.LC0, %edi  call puts  movl $0, %edi  call exit .L7:  movq 8(%rsi), %rdi  movl $10, %edx  movl $0, %esi  call strtol  movl %eax, %edi  call fib  movq %rax, %rdx  movl $.LC1, %esi  movl $1, %edi  movl $0, %eax  call __printf_chk  movl $0, %eax  addq $8, %rsp  .cfi_def_cfa_offset 8  ret  .cfi_endproc .LFE39:  .size main, .-main  .ident “GCC: (Ubuntu 5.4.0–6ubuntu1~16.04.2) 5.4.0 20160609”  .section .note.GNU-stack,"",@progbits Quite straight forward to this point, isn’t it? Without much knowledge about x86_64 assembly we see our call at line 54. And as it’s in the calling convention of ABI64 we get our argument in register %edi and will have to provide the result in %eax.Now we are just cutting out the “fib” part above and put it in a single file. I will call it “fib.S”, from line 2 to 28. We clean up a bit and let’s take a look.First we don’t need the stack frame exception handler marker .cfi and just kill that.Then we are renaming some of the labels in a sensible way..text  .globl fib  .type fib, @function fib:  cmpl $2, %edi  jle .exit1  movl $1, %ecx  movl $1, %esi  movl $2, %edx  jmp .enter //----------------------------- .do:  movq %rax, %rcx .enter:  leaq (%rsi,%rcx), %rax  addl $1, %edx  movq %rcx, %rsi  cmpl %edx, %edi  jne .do //------------------------------  ret .exit1:  movl $1, %eax  ret And now we take out the fib function of our main C routine and replace it withunsigned long fib(int f); Now we compile the whole thing with:> cc -O3 -o optimize optimize.c fib.S > ./optimize 6 8 > ls -l optimize -rwxr-xr-x 1 user user 6336 Aug 15 16:31 optimize Done. Now we can start on working on our assembly part.But this is not about optimizing; this is about how we get that started. BTW, gcc is doing a pretty good job with this one and if we let it do all its work, it would even start to unroll our loop a bit as well as it’s inlining the whole code if we let it, what we forbid in this case by not marking it as “inline” by the definition.It’s pretty smart that “leaq” move is an addition of %rsi and %rcx to %rax in just one movement. And that’s quite fly for a compiler, so that you may, if you can, whistle at this feat.I hope I could help. Well. We could exchange the addl $1, %rsi with an incl %rsi, and I bet that’s faster. But you really would do a lot of work by unrolling here. If you are tempted to exchange cmpl/jne with a LOOPNE command and move the counter into %ecx, this could help a bit, but know that cmp/jmp combinations are ONE command on modern processors not two. So it’s in this case hard to beat and not much to gain.But anyway, it’s a demo. I hope I could help. Feel free to play around with it and measure your cycles, try to get it to inline your code again and try to beat the original code with -O3 with your own assembly. It *is* possible. But you’ll have to find out yourself.:)Well, I couldn’t stop me playing around a bit with the code, just to show what a human can do to a compiler code. Do you have a better one? Is mine really faster? Test yourself. Fiddle around with that. By the way, the fib values of 92 or so is the highest. So there’s not much need for optimizing the loop for 64 bit values and I could have limited the input to char values. Whatever…This is one of the functions that were better off with 128 bit values or more.With four commands in the loop I managed to be in the “four commands decoding register” of my AMD64, which means that that thing will not decode any commands and just execute them all together in microcode. Which will maybe not safe cycles, but at least power consumption as well as work perfect in cache.If it’s really about speed now, the only way to get faster, I’d wager, would be using a table. I decided against xor %eax, %eax; inc %eax, to load %eax with 1, by the way, because that’s a lost cycle and only saves one byte.I was a bit pessimistic if there was anything to do about the compiler’s code, but I guess this result, even on such a small scale is pretty impressive. Now think about what you can do to a real algorithm, if you work it over..text  .globl fib  .type fib, @function fib:  mov $1, %eax // set return value 1 if 1,2  leaq -2(%rdi), %rcx // c = d-2, set cx=counter  cmp $0, %rcx // cmp+jmp joins to one command  jle .exit1 // exit for return 1, else c>0  mov %eax, %edx // d=1 (n[1])  mov %eax, %esi // s=1 (n[2])  jmp .enter //----------------------------- .do:  movq %rax, %rdx // n[1]=n[0] .enter:  leaq (%rsi,%rdx), %rax // n[0]=n[1]+n[2]  movq %rdx, %rsi // n[2]=n[1]  loop .do // dec cx counter jump if not equal //------------------------------ .exit1:  ret By the way, I stripped the final file with:> strip -s -x -R .comment -R .note fib which got rid of all those nasty GCC version numbers and things like that and got the file down to 6,216 bytes. That’s legit, I think. And if you want to anonymize your file, you should do that, because all the info in those sections are like a fingerprint. On the other hand you can hide information in your executables, like serial numbers and so on or just insert something like, search your file for that strings after that…#ident “Author: Hanno Behrens for Quora” #ident “Mail: do not post this on a forum” Another edit, now, help me, I couldn’t stop myself. Here you got the “Duff’s device” optimization of partial unrolling the Fibonacci-loop. Yeah, I know it is totally wasted for this problem, but I did it anyway. The unrolling is by four (see the .rept block to build the code and that neat recursive macro to build that table), you can do it in 2^x. It’s generating automatic jump tables and is by now the fastest Fibonacci ever, aside of pure tables. This thing is like nuking a fly. But at least there is never again a Fibonacci function necessary on this planet after this, and it should be the final answer to “compilers do better code than humans”. I think not so much..macro dufftable start, incr, from=0, to=3  .quad \start+(1+\to-\from)%(\to+1)*\incr  .if \to-\from  dufftable \start, \incr, “(\from+1)”, \to  .endif .endm   .text  .globl fib  .type fib, @function fib:  mov $1, %eax // set return value 1 if 1,2  leaq -2(%rdi), %rcx // c = d-2, set cx=counter  cmp $0, %rcx // cmp+jmp joins to one command  jle exit1 // exit for return 1, else c>0  mov %eax, %edx // d=1 (n[1])  mov %eax, %esi // s=1 (n[2])  mov %ecx, %eax // a=c offset  and $3, %eax // a=c%4  add $3, %ecx // c+=3 calculate rounds  shr $2, %ecx // c/=4  jmp *.table(,%eax,8) // jump over table “Duff’s Device” .table: dufftable denter, (.block-.do), 0, 3  //----------------------------- .do:  movq %rax, %rdx // n[1]=n[0] denter:  leaq (%rsi,%rdx), %rax // n[0]=n[1]+n[2]  movq %rdx, %rsi // n[2]=n[1] .block:  .rept 3  movq %rax, %rdx // n[1]=n[0]  leaq (%rsi,%rdx), %rax // n[0]=n[1]+n[2]  movq %rdx, %rsi // n[2]=n[1]  .endr   loop .do // dec cx counter jump if not equal //------------------------------ exit1:  ret Output:> for i in {1..92}; do printf “%02d%20lu\n” $i $(fib $i); done; 01 1 02 1 03 2 04 3 05 5 06 8 07 13 08 21 09 34 10 55 11 89 12 144 13 233 14 377 15 610 16 987 17 1597 18 2584 19 4181 20 6765 21 10946 22 17711 23 28657 24 46368 25 75025 26 121393 27 196418 28 317811 29 514229 30 832040 31 1346269 32 2178309 33 3524578 34 5702887 35 9227465 36 14930352 37 24157817 38 39088169 39 63245986 40 102334155 41 165580141 42 267914296 43 433494437 44 701408733 45 1134903170 46 1836311903 47 2971215073 48 4807526976 49 7778742049 50 12586269025 51 20365011074 52 32951280099 53 53316291173 54 86267571272 55 139583862445 56 225851433717 57 365435296162 58 591286729879 59 956722026041 60 1548008755920 61 2504730781961 62 4052739537881 63 6557470319842 64 10610209857723 65 17167680177565 66 27777890035288 67 44945570212853 68 72723460248141 69 117669030460994 70 190392490709135 71 308061521170129 72 498454011879264 73 806515533049393 74 1304969544928657 75 2111485077978050 76 3416454622906707 77 5527939700884757 78 8944394323791464 79 14472334024676221 80 23416728348467685 81 37889062373143906 82 61305790721611591 83 99194853094755497 84 160500643816367088 85 259695496911122585 86 420196140727489673 87 679891637638612258 88 1100087778366101931 89 1779979416004714189 90 2880067194370816120 91 4660046610375530309 92 7540113804746346429 

BrainfuckOkay, this has no language specification? Then this is my submit:>+++++++++[<+++++++++>-]<++.>+++++[<+++++>-]<+.----.+++.-------.>++++++++[<-------->-]<----.>++++++ +[<+++++++>-]<+.>+++++[<+++++>-]<+.----.+++.-------.>++++++++[<-------->-]<----.>+++++++[<+++++++>- ]<+.>+++++[<+++++>-]<+.----.+++.-------.>++++++++[<-------->-]<----.>++++[<------>-]<+.>++++++++[<+ ++++++++>-]<+.>+++++[<+++++>-]<+.----.+++.-------.>++++++++[<-------->-]<----.>+++++++[<+++++++>-]< +.>+++++[<+++++>-]<+.----.+++.-------.>++++++++[<-------->-]<----.>++++[<------>-]<+.>++++++++[<+++ ++++++>-]<+.>+++++[<+++++>-]<+.----.+++.-------.>++++++++[<-------->-]<----.>++++[<------>-]<+. compile with> ./bfc <smile.bf >smile > ./smile  Smile!Smile!Smile!  Smile!Smile!  Smile! > ls -l smile{.bf,}  -rwxr-xr-x 1 user user 1601 Aug 13 13:42 smile*  -rw-r--r-- 1 user user 590 Aug 13 13:42 smile.bf This was “Smiling” Brainfuck.Ah! User-12551941622543608532 was faster with his and he wasn’t so lazy as poor me. I like his code.C=64: MOS6502 assemblySo, after have seen that my Brainfuck solution was not the only one I submit a second one: 6502 Assembly on a C64!Program:; xa -O PETSCII -o smile smile.asm  print = $ffd2   *= $0801  .text ;generate header  .word * ; loading address $0801  *= *-2 ; these 2 bytes do not actually load  .word endline ;pointer on next line  .word 2016 ;line number  .byt $9e ;Basic SYS (jumps into machine code)  .asc “2061”,0 ;at address 2061=$080d is our “start” endline .word 0 ;last line ends with end-word zero ;end Header  start lda #$b7 ;binary 10110111 l1 lsr ;next word  bcc lf ;shifting down, zero bit -> linefeed  tax ;safe akku  ldy #$00 ;print string from index 0 prloop lda msg,y ; load next char from msg  beq endmsg ;until 0 marks end  jsr print   iny ;increase index  bne prloop ;jump to print next char endmsg txa ;restore akku  bne l1 ;if not 0 (should not) jump to next word lf beq return ; end program  tax ;safe accu  lda #$0d ;CR (=linefeed)  jsr print  txa ;restore akku  bne l1 ;next word return rts  msg: .asc “smile!”,0  .end I included the BASIC header into the assembly file, so you can just load it with LOAD “smile”,8 and run it by RUN.I used the VICE C64 emulator x64 for that. And implemented it as a finite state machine without subroutines (print is a system call, okay, point taken).> hexdump -C smile 00000000 01 08 0b 08 e0 07 9e 32 30 36 31 00 00 00 a9 b7 |…….2061…..| 00000010 4a 90 11 aa a0 00 b9 2f 08 f0 06 20 d2 ff c8 d0 |J……/… ….| 00000020 f5 8a d0 ec f0 09 aa a9 0d 20 d2 ff 8a d0 e1 60 |……… …..`| 00000030 53 4d 49 4c 45 21 00 |SMILE!.| 00000037 And I hope I could really help you, doing your homework. If you submit this fine little 6502 program, you will beat it.Edit:I was asked inside the comment section to elaborate about this assembly program. The comment is not a good place for that so I do that here.The Commodore 64 is an 8 bit computer from 1982. I used the assembler “xa” for assembling.The processors has three registers: A, X, Y. Which are 8 bit registers, means they can store one byte. The CPU can only do something in registers never in the memory, that’s the same back then as today.Line 16:LDA loads a value in the the Akku, means “A” register. I have chosen 10110111 because my plan is to shift the bits out to the right side of the akku so there will be first 3x 1 then a 0 then 2x 1 then a 0 then 1x1. Which is our pattern. The 0 will be a new line .17:LSR “logical shift right” will do exactly that. Shift all bits to the right and move the falling out bit into the carry flag “C”. The processor has a few flags that show the result of the last operation, like zero, carry, overflow, sign and a few other, which are here not important.Zero will get set if the result was zero. Sign if it was negative, means binary 10000000 or hex $80, means upper bit set. Overflow means we crossed from $80 to $7f or the other way around. Means from -128 to 127.18:BCC branch on carry clear. Means if we have a clear carry, the shifted out bit was zero, then jump to label “lf” means linefeed.19:TAX transfer A to X, I move the value to X because I need the akku for printing, just saving it and it’s much faster to operate on registers than on memory20: the printingLDY load Y register with zero. Y is an index register that you can use to add it to a memory address. mem,Y means “address mem+Y”. I will use it to index the “SMILE!” string at the end of the program at the label “msg”.21:LDA load akku with msg,Y means with first character plus Y index.22:BEQ branch on equal, means if A is zero (end of string then jump to end message printng23:JSR jump subroutine “print”, is declared in the header as $FFD2 which is the jump in for to output a character in the Kernel of the C64. It’s the same as INT $80, just in the old days and without using a time consuming interrupt.It will print the character in the accu. Like “C” putchar().24:INY increase Y register means Y = Y+125:BNE prloop will always jump back to start of printing. While our Y is only zero if we count up to $FF and +1=0. But we ill never reach this. The JMP (Jump) command takes a byte more and is slower.26:TXA transfer X to A, I restore my shift register27:and jump back to L1, means back to shifting. It will not get zero ever. So this is the end of this part. I could have made a ———————- which I should have done maybe28: lfBEQ return branch on equal to label returnbut if I do and it’s equal I jump to return which will get back to the system and terminate my program. But originally I am coming here after shifting. Means “if my carry was clear, jump to LF” was directly after shift. If my result is also ZERO there are no more bits to shift and that was the last run. So: jump to return29:TAX again safe my akku because we are printing30:LDA #13 load akku with 13 which is CR (carriage return) which is the linefeed on the C64 output31:JSR print and output of CR32:TXA restore my akku, means shift register, which MUST be not zero33:BNE l1 branch on not equal to go on with shifting and producing the next word.Big line here, it will never go further than this.34: returnRTS return from subroutine will return to OS means BASIC on the C64 and produce a READY. on the prompt. That’s end program.on line 36 there is the string. On 38 I ended the program with the pseudoopcode .end which is not a must, but I do it anyway. It’s just to show the assembler, that there is no more code. I could have written anything below that.More about the 6502 here: 6502/6510/8500/8502 OpcodesAt the start of the program there is more or less just a special bytecode, which is the starting address of the program $0801 and the BASIC lines how they need to be in memory to be accepted for C64 BASIC. The SYS command does a jump to the address, in this case 2061 which is hex $080d, the start of our first command “LDA $B7” assembles to A9 B7, which you can also find in the hexdump.Every line starts with a line number and the pointer to the next line. The last line is pointing to zero and ending the program. That’s the “header” of this program.Final Note:I could have spared some bytes in the printing loop, if I had counted Y down to zero and put the printing string reversed in memory. Also I would not had needed the closing zero after the string. 3 bytes spared and some cycles. Before some smart ass tells me that… And I got rid of all those annoying TAX/TXA with a bit of optimization. I had it in my guts that this wasn’t right. I hate it, when pattern repeat.Like this:start ldx #%10110111 ;---state 1: binary 1->2, binary 0->3 s1 txa  lsr  tax  bcc lf ;---state 2  ldy #msge-msg prl lda msg-1,y  jsr print  dey  bne prl  beq s1 ;---state 3 lf beq return ; shr done -> exit  lda #$0d  jsr print  bne s1 ;---exit return rts  msg: .asc “!elims” msge: Dump:00000000 01 08 0b 08 e0 07 9e 32 30 36 31 00 00 00 a2 b7 |…….2061…..| 00000010 8a 4a aa 90 0d a0 06 b9 2a 08 20 d2 ff 88 d0 f7 |.J……*. …..| 00000020 f0 ee f0 07 a9 0d 20 d2 ff d0 e5 60 21 45 4c 49 |…… ….`!ELI| 00000030 4d 53 |MS| In assembly you can also count up to zero and just offset the string by it’s length. Whatever. I think every opcode now serves one purpose of that algorithm and if I start thinking about that for a bit longer, I will still find the one or other byte to spare. But we are down to 36 bytes of program length plus header and file format makes 50 bytes. I’m a bit longer than the code golf variant but I don’t have to spoil the system with all that crappy Python environment. That are 36 bytes of code, which should be enough for this. But - yeah - 5 bytes less. Can’t see any more at the moment.That should be enough for your homework.SEDAnd of course you might want to have a simple solution on the shell, done with SED:> echo “smile\!”|sed -e 's/\(.*\)/\U\1/;s/\([A-Z!]*\)/\1\1\1\n\1\1\n\1/'  SMILE!SMILE!SMILE!  SMILE!SMILE!  SMILE! 

Elastic modulusAn elastic modulus (also known as modulus of elasticity) is a quantity that measures an object or substance's resistance to being deformed elastically5 KB (554 words) - 15:15, 21 May 2018Specific modulusSpecific modulus is a materials property consisting of the elastic modulus per mass density of a material. It is also known as the stiffness to weight39 KB (1,388 words) - 15:52, 11 September 2018Bulkdensity Bulk modulus In brane cosmology and M-theory, the bulk is a hypothetical higher-dimensional space within which the eleven dimensions of our universe1 KB (131 words) - 15:18, 19 July 2018Speed of soundis Young's modulus. This is similar to the expression for shear waves, save that Young's modulus replaces the shear modulus. This speed of sound for pressure52 KB (7,590 words) - 03:38, 10 September 2018Impulse excitation technique (section Young's modulus)internal friction of a material of interest. It measures the resonant frequencies in order to calculate the Young's modulus, shear modulus, Poisson's ratio12 KB (1,646 words) - 12:08, 28 April 2018Stiffnessis the (tensile) elastic modulus (or Young's modulus), L is the length of the element.Similarly, the torsional stiffness of a straight section is9 KB (1,191 words) - 19:03, 11 September 2018Strength of materialsquantities is a straight line.The slope of this line is known as Young's modulus, or the "modulus of elasticity." The modulus of elasticity can be used to determine25 KB (3,550 words) - 03:13, 10 September 2018Elasticity (physics) (redirect from Elasticity of materials)such as Young's modulus, the shear modulus, and the bulk modulus, all of which are measures of the inherent elastic properties of a material as a resistance17 KB (2,395 words) - 03:48, 10 September 2018I-beama given section modulus. Since the section modulus depends on the value of the moment of inertia, an efficient beam must have most of its material located19 KB (2,163 words) - 20:56, 24 January 2018Linear congruential generator (section m a power of 2, c=0)< m {\displaystyle m,\,0<m} — the "modulus" a , 0 <29 KB (3,381 words) - 02:38, 6 August 2018Poisson's ratio (section Applications of Poisson's effect)less than 0.5 because of the requirement for Young's modulus, the shear modulus and bulk modulus to have positive values. Most materials have Poisson's24 KB (3,542 words) - 08:24, 25 July 2018Torsion constant (section Thin walled open tube of uniform thickness)} is the angle of twist in radians T is the applied torque L is the beam length G is the Modulus of rigidity (shear modulus) of the material J is the5 KB (777 words) - 17:40, 1 August 2018Shear strengthShear modulus Shear stress Shear strain Shear strength (soil) Shear strength (Discontinuity) Strength of materials Tensile strength "Shear Strength of Metals"4 KB (408 words) - 13:57, 31 July 2018Deflection (engineering){\displaystyle E} = Modulus of elasticity I {\displaystyle I} = Area moment of inertia of the beam's cross sectionNote11 KB (1,745 words) - 15:33, 13 August 2018Hardnessnot to any rigidity or stiffness properties such as its bulk modulus or Young's modulus. Stiffness is often confused for hardness. Some materials are16 KB (1,841 words) - 00:30, 6 September 2018Pure bending (section Kinematics of pure bending)form a neutral surface. The material of the beam is homogeneous1 and isotropic2. The value of Young's Modulus of Elasticity is same in tension and compression2 KB (276 words) - 17:23, 14 July 2018RANDU (section Problems with multiplier and modulus)simulation. Choice of multiplier determines the number of planes. To show the problem with the values of multiplier 65539 and modulus 231 chosen for RANDU5 KB (711 words) - 21:16, 20 July 2018Dimensionless quantity (redirect from List of Non Dimensional Numbers)convenient to drop the assignment of explicit dimensions and express the quantities without dimensions, e.g., addressing the speed of light simply by the dimensionless13 KB (1,603 words) - 10:53, 14 July 2018Extremal length (redirect from Discrete modulus)works with the conformal modulus of Γ {\displaystyle \Gamma } , the reciprocal of the extremal length. The fact19 KB (4,176 words) - 13:47, 16 May 2018Nanowire (category CS1 maint: Explicit use of et al.)applied to study the modulus of silver nanowires, and again the modulus was found to be 88 GPa, very similar to the modulus of bulk Silver (85 GPa) These44 KB (5,300 words) - 08:15, 12 September 2018dimensions of modulus - Search results - Wikipedia