Snapman系统中TCC执行效率和C#执行效率对比

2018-06-18 04:01:01来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

Snapman集合了TCC编译器可以直接编译执行C语言脚本,其脚本执行效率和C#编译程序进行效率对比,包括下面4方面:

1、函数执行效率

2、数字转换成字符串

3、字符串的叠加

4、MD5算法

这是C#代码:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Collections;

namespace TestEfficiency
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        int fibonacci(int n)
        {
            if (n == 1 || n == 2)
                return 1;
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
        string numberConvert()
        {
            string result = "";
            for (int i = 0; i < 14000000; i++ )
            {
                result = i.ToString();
            }
            return result;
        }
        string stringAppend()
        {
            string conc = "StringBuilder sb = new StringBuilder(1024);";
            StringBuilder sb = new StringBuilder(1024);
            for (int i = 0; i < 1400; i++)
            {
                sb = new StringBuilder(1024);
                for (int j = 0; j < 10000; j++ )
                {
                    sb.Append(conc);
                }
            }
            return sb.ToString();
        }
        public class MD5
        {
            //static state variables
            private static UInt32 A;
            private static UInt32 B;
            private static UInt32 C;
            private static UInt32 D;

            //number of bits to rotate in tranforming
            private const int S11 = 7;
            private const int S12 = 12;
            private const int S13 = 17;
            private const int S14 = 22;
            private const int S21 = 5;
            private const int S22 = 9;
            private const int S23 = 14;
            private const int S24 = 20;
            private const int S31 = 4;
            private const int S32 = 11;
            private const int S33 = 16;
            private const int S34 = 23;
            private const int S41 = 6;
            private const int S42 = 10;
            private const int S43 = 15;
            private const int S44 = 21;

            /* F, G, H and I are basic MD5 functions.
             * 四个非线性函数:
             * 
             * F(X,Y,Z) =(X&Y)|((~X)&Z)
             * G(X,Y,Z) =(X&Z)|(Y&(~Z))
             * H(X,Y,Z) =X^Y^Z
             * I(X,Y,Z)=Y^(X|(~Z))
             * 
             * (&与,|或,~非,^异或)
             */
            private static UInt32 F(UInt32 x, UInt32 y, UInt32 z)
            {
                return (x & y) | ((~x) & z);
            }
            private static UInt32 G(UInt32 x, UInt32 y, UInt32 z)
            {
                return (x & z) | (y & (~z));
            }
            private static UInt32 H(UInt32 x, UInt32 y, UInt32 z)
            {
                return x ^ y ^ z;
            }
            private static UInt32 I(UInt32 x, UInt32 y, UInt32 z)
            {
                return y ^ (x | (~z));
            }

            /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
             * Rotation is separate from addition to prevent recomputation.
             */
            private static void FF(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + F(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }
            private static void GG(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + G(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }
            private static void HH(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + H(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }
            private static void II(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + I(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }

            private static void MD5_Init()
            {
                A = 0x67452301; //in memory, this is 0x01234567
                B = 0xefcdab89; //in memory, this is 0x89abcdef
                C = 0x98badcfe; //in memory, this is 0xfedcba98
                D = 0x10325476; //in memory, this is 0x76543210
            }

            private static UInt32[] MD5_Append(byte[] input)
            {
                int zeros = 0;
                int ones = 1;
                int size = 0;
                int n = input.Length;
                int m = n % 64;
                if (m < 56)
                {
                    zeros = 55 - m;
                    size = n - m + 64;
                }
                else if (m == 56)
                {
                    zeros = 0;
                    ones = 0;
                    size = n + 8;
                }
                else
                {
                    zeros = 63 - m + 56;
                    size = n + 64 - m + 64;
                }

                ArrayList bs = new ArrayList(input);
                if (ones == 1)
                {
                    bs.Add((byte)0x80); // 0x80 = $10000000
                }
                for (int i = 0; i < zeros; i++)
                {
                    bs.Add((byte)0);
                }

                UInt64 N = (UInt64)n * 8;
                byte h1 = (byte)(N & 0xFF);
                byte h2 = (byte)((N >> 8) & 0xFF);
                byte h3 = (byte)((N >> 16) & 0xFF);
                byte h4 = (byte)((N >> 24) & 0xFF);
                byte h5 = (byte)((N >> 32) & 0xFF);
                byte h6 = (byte)((N >> 40) & 0xFF);
                byte h7 = (byte)((N >> 48) & 0xFF);
                byte h8 = (byte)(N >> 56);
                bs.Add(h1);
                bs.Add(h2);
                bs.Add(h3);
                bs.Add(h4);
                bs.Add(h5);
                bs.Add(h6);
                bs.Add(h7);
                bs.Add(h8);
                byte[] ts = (byte[])bs.ToArray(typeof(byte));

                /* Decodes input (byte[]) into output (UInt32[]). Assumes len is
                 * a multiple of 4.
                 */
                UInt32[] output = new UInt32[size / 4];
                for (Int64 i = 0, j = 0; i < size; j++, i += 4)
                {
                    output[j] = (UInt32)(ts[i] | ts[i + 1] << 8 | ts[i + 2] << 16 | ts[i + 3] << 24);
                }
                return output;
            }
            private static UInt32[] MD5_Trasform(UInt32[] x)
            {

                UInt32 a, b, c, d;

                for (int k = 0; k < x.Length; k += 16)
                {
                    a = A;
                    b = B;
                    c = C;
                    d = D;

                    /* Round 1 */
                    FF(ref a, b, c, d, x[k + 0], S11, 0xd76aa478); /* 1 */
                    FF(ref d, a, b, c, x[k + 1], S12, 0xe8c7b756); /* 2 */
                    FF(ref c, d, a, b, x[k + 2], S13, 0x242070db); /* 3 */
                    FF(ref b, c, d, a, x[k + 3], S14, 0xc1bdceee); /* 4 */
                    FF(ref a, b, c, d, x[k + 4], S11, 0xf57c0faf); /* 5 */
                    FF(ref d, a, b, c, x[k + 5], S12, 0x4787c62a); /* 6 */
                    FF(ref c, d, a, b, x[k + 6], S13, 0xa8304613); /* 7 */
                    FF(ref b, c, d, a, x[k + 7], S14, 0xfd469501); /* 8 */
                    FF(ref a, b, c, d, x[k + 8], S11, 0x698098d8); /* 9 */
                    FF(ref d, a, b, c, x[k + 9], S12, 0x8b44f7af); /* 10 */
                    FF(ref c, d, a, b, x[k + 10], S13, 0xffff5bb1); /* 11 */
                    FF(ref b, c, d, a, x[k + 11], S14, 0x895cd7be); /* 12 */
                    FF(ref a, b, c, d, x[k + 12], S11, 0x6b901122); /* 13 */
                    FF(ref d, a, b, c, x[k + 13], S12, 0xfd987193); /* 14 */
                    FF(ref c, d, a, b, x[k + 14], S13, 0xa679438e); /* 15 */
                    FF(ref b, c, d, a, x[k + 15], S14, 0x49b40821); /* 16 */

                    /* Round 2 */
                    GG(ref a, b, c, d, x[k + 1], S21, 0xf61e2562); /* 17 */
                    GG(ref d, a, b, c, x[k + 6], S22, 0xc040b340); /* 18 */
                    GG(ref c, d, a, b, x[k + 11], S23, 0x265e5a51); /* 19 */
                    GG(ref b, c, d, a, x[k + 0], S24, 0xe9b6c7aa); /* 20 */
                    GG(ref a, b, c, d, x[k + 5], S21, 0xd62f105d); /* 21 */
                    GG(ref d, a, b, c, x[k + 10], S22, 0x2441453); /* 22 */
                    GG(ref c, d, a, b, x[k + 15], S23, 0xd8a1e681); /* 23 */
                    GG(ref b, c, d, a, x[k + 4], S24, 0xe7d3fbc8); /* 24 */
                    GG(ref a, b, c, d, x[k + 9], S21, 0x21e1cde6); /* 25 */
                    GG(ref d, a, b, c, x[k + 14], S22, 0xc33707d6); /* 26 */
                    GG(ref c, d, a, b, x[k + 3], S23, 0xf4d50d87); /* 27 */
                    GG(ref b, c, d, a, x[k + 8], S24, 0x455a14ed); /* 28 */
                    GG(ref a, b, c, d, x[k + 13], S21, 0xa9e3e905); /* 29 */
                    GG(ref d, a, b, c, x[k + 2], S22, 0xfcefa3f8); /* 30 */
                    GG(ref c, d, a, b, x[k + 7], S23, 0x676f02d9); /* 31 */
                    GG(ref b, c, d, a, x[k + 12], S24, 0x8d2a4c8a); /* 32 */

                    /* Round 3 */
                    HH(ref a, b, c, d, x[k + 5], S31, 0xfffa3942); /* 33 */
                    HH(ref d, a, b, c, x[k + 8], S32, 0x8771f681); /* 34 */
                    HH(ref c, d, a, b, x[k + 11], S33, 0x6d9d6122); /* 35 */
                    HH(ref b, c, d, a, x[k + 14], S34, 0xfde5380c); /* 36 */
                    HH(ref a, b, c, d, x[k + 1], S31, 0xa4beea44); /* 37 */
                    HH(ref d, a, b, c, x[k + 4], S32, 0x4bdecfa9); /* 38 */
                    HH(ref c, d, a, b, x[k + 7], S33, 0xf6bb4b60); /* 39 */
                    HH(ref b, c, d, a, x[k + 10], S34, 0xbebfbc70); /* 40 */
                    HH(ref a, b, c, d, x[k + 13], S31, 0x289b7ec6); /* 41 */
                    HH(ref d, a, b, c, x[k + 0], S32, 0xeaa127fa); /* 42 */
                    HH(ref c, d, a, b, x[k + 3], S33, 0xd4ef3085); /* 43 */
                    HH(ref b, c, d, a, x[k + 6], S34, 0x4881d05); /* 44 */
                    HH(ref a, b, c, d, x[k + 9], S31, 0xd9d4d039); /* 45 */
                    HH(ref d, a, b, c, x[k + 12], S32, 0xe6db99e5); /* 46 */
                    HH(ref c, d, a, b, x[k + 15], S33, 0x1fa27cf8); /* 47 */
                    HH(ref b, c, d, a, x[k + 2], S34, 0xc4ac5665); /* 48 */

                    /* Round 4 */
                    II(ref a, b, c, d, x[k + 0], S41, 0xf4292244); /* 49 */
                    II(ref d, a, b, c, x[k + 7], S42, 0x432aff97); /* 50 */
                    II(ref c, d, a, b, x[k + 14], S43, 0xab9423a7); /* 51 */
                    II(ref b, c, d, a, x[k + 5], S44, 0xfc93a039); /* 52 */
                    II(ref a, b, c, d, x[k + 12], S41, 0x655b59c3); /* 53 */
                    II(ref d, a, b, c, x[k + 3], S42, 0x8f0ccc92); /* 54 */
                    II(ref c, d, a, b, x[k + 10], S43, 0xffeff47d); /* 55 */
                    II(ref b, c, d, a, x[k + 1], S44, 0x85845dd1); /* 56 */
                    II(ref a, b, c, d, x[k + 8], S41, 0x6fa87e4f); /* 57 */
                    II(ref d, a, b, c, x[k + 15], S42, 0xfe2ce6e0); /* 58 */
                    II(ref c, d, a, b, x[k + 6], S43, 0xa3014314); /* 59 */
                    II(ref b, c, d, a, x[k + 13], S44, 0x4e0811a1); /* 60 */
                    II(ref a, b, c, d, x[k + 4], S41, 0xf7537e82); /* 61 */
                    II(ref d, a, b, c, x[k + 11], S42, 0xbd3af235); /* 62 */
                    II(ref c, d, a, b, x[k + 2], S43, 0x2ad7d2bb); /* 63 */
                    II(ref b, c, d, a, x[k + 9], S44, 0xeb86d391); /* 64 */

                    A += a;
                    B += b;
                    C += c;
                    D += d;
                }
                return new UInt32[] { A, B, C, D };
            }
            public static byte[] MD5Array(byte[] input)
            {
                MD5_Init();
                UInt32[] block = MD5_Append(input);
                UInt32[] bits = MD5_Trasform(block);

                /* Encodes bits (UInt32[]) into output (byte[]). Assumes len is
                 * a multiple of 4.
                   */
                byte[] output = new byte[bits.Length * 4];
                for (int i = 0, j = 0; i < bits.Length; i++, j += 4)
                {
                    output[j] = (byte)(bits[i] & 0xff);
                    output[j + 1] = (byte)((bits[i] >> 8) & 0xff);
                    output[j + 2] = (byte)((bits[i] >> 16) & 0xff);
                    output[j + 3] = (byte)((bits[i] >> 24) & 0xff);
                }
                return output;
            }

            public static string ArrayToHexString(byte[] array, bool uppercase)
            {
                string hexString = "";
                string format = "x2";
                if (uppercase)
                {
                    format = "X2";
                }
                foreach (byte b in array)
                {
                    hexString += b.ToString(format);
                }
                return hexString;
            }

            public static string MDString(string message)
            {
                char[] c = message.ToCharArray();
                byte[] b = new byte[c.Length];
                for (int i = 0; i < c.Length; i++)
                {
                    b[i] = (byte)c[i];
                }
                byte[] digest = MD5Array(b);
                return ArrayToHexString(digest, false);
            }
        }
        string testMd5()
        {
            
            string conc = "StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);";
            conc = conc + conc + conc + conc + conc + conc + conc + conc;
            string about = "";
            for (int i = 0; i < 100000; i++ )
            {
               about = MD5.MDString(conc);
            }
            return about;
        }
        private void button1_Click(object sender, EventArgs e)
        {
            DateTime fbeforDT = System.DateTime.Now;
            fibonacci(45); 
            DateTime fafterDT = System.DateTime.Now;
            TimeSpan ts = fafterDT.Subtract(fbeforDT);
            textBox1.Text = string.Format("fibonacci spend: {0}ms.", ts.TotalMilliseconds);

            DateTime nbeforDT = System.DateTime.Now;
            numberConvert();
            DateTime nafterDT = System.DateTime.Now;
            TimeSpan nts = nafterDT.Subtract(nbeforDT);
            textBox2.Text = string.Format("numberConvert spend: {0}ms.", nts.TotalMilliseconds);

            DateTime sbeforDT = System.DateTime.Now;
            stringAppend();
            DateTime safterDT = System.DateTime.Now;
            TimeSpan sts = safterDT.Subtract(sbeforDT);
            textBox3.Text = string.Format("stringAppend spend: {0}ms.", sts.TotalMilliseconds);

            DateTime mbeforDT = System.DateTime.Now;
            testMd5();
            DateTime mafterDT = System.DateTime.Now;
            TimeSpan mts = mafterDT.Subtract(mbeforDT);
            textBox4.Text = string.Format("testMd5 spend: {0}ms.", mts.TotalMilliseconds);

        }
    }
    
}
View Code

这是C#编译出来Release的页面:

这是Snapman系统中写的TCC脚本代码:

int fibonacci(int n)  
{  
    if(n==1||n==2)  
        return 1;  
    return fibonacci(n-1) + fibonacci(n-2);  
}
char* numberConvert()
{
    char* result = (char*)malloc(128);
    for (int i = 0; i < 14000000; i++ )
    {
        itoa(i,result,10);
    }
    return result;
}
char* stringAppend()
{
    char* conc = "StringBuilder sb = new StringBuilder(1024);";
    char* sb = (char*)malloc(1024);
    int len = 1024, cl = strlen(conc), curlen = 0;
    for (int i = 0; i < 1400; i++)
    {
        free(sb);
        len = 1024;
        curlen = 0;
        sb = (char*)malloc(1024);
        for(int j = 0; j < 10000; j++)
        {
            if(curlen + cl > len)
            {
                sb = (char*)realloc(sb,len*2);
                len *= 2;
            }
            memcpy(sb+curlen,conc,cl);
            curlen += cl;
        }
    }
    sb[curlen] = 0;
    return sb;
}

#define S11 7 
#define S12 12 
#define S13 17 
#define S14 22 
#define S21 5 
#define S22 9 
#define S23 14 
#define S24 20 
#define S31 4 
#define S32 11 
#define S33 16 
#define S34 23 
#define S41 6 
#define S42 10 
#define S43 15 
#define S44 21 

static unsigned char PADDING[64] = { 
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
}; 

#define   F(x, y, z) (((x) & (y)) | ((~x) & (z))) 
#define   G(x, y, z) (((x) & (z)) | ((y) & (~z))) 
#define   H(x, y, z) ((x) ^ (y) ^ (z)) 
#define   I(x, y, z) ((y) ^ ((x) | (~z))) 

#define   ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) 

#define   FF(a, b, c, d, x, s, ac) {   (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b);   } 
#define   GG(a, b, c, d, x, s, ac) {   (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b);   } 
#define   HH(a, b, c, d, x, s, ac) {   (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b);   } 
#define   II(a, b, c, d, x, s, ac) {   (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b); } 

typedef unsigned char *POINTER; 
typedef unsigned short int UINT2; 
typedef unsigned long int UINT4; 
typedef struct   
{ 
    UINT4 state[4]; 
    UINT4 count[2]; 
    unsigned char buffer[64]; 
} MD5_CTX; 

void Encode(unsigned char *output, UINT4 *input, unsigned int len) 
{ 
    unsigned int i, j; 

    for (i = 0, j = 0; j < len; i++, j += 4) { 
        output[j]   = (unsigned char)(input[i] & 0xff); 
        output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); 
        output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); 
        output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); 
    } 
} 

void Decode(UINT4 *output, unsigned char *input, unsigned int len) 
{ 
    unsigned int i, j; 

    for (i = 0, j = 0; j < len; i++, j += 4) 
    {
        output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | 
            (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24); 
    }
} 

void MD5Transform (UINT4 state[4], unsigned char block[64]) 
{ 
    UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; 
    Decode (x, block, 64); 
    FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ 
    FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ 
    FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ 
    FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ 
    FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ 
    FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ 
    FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ 
    FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ 
    FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ 
    FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ 
    FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ 
    FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ 
    FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ 
    FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ 
    FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ 
    FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ 
    GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ 
    GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ 
    GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ 
    GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ 
    GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ 
    GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */ 
    GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ 
    GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ 
    GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ 
    GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ 
    GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ 
    GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ 
    GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ 
    GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ 
    GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ 
    GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ 
    HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ 
    HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ 
    HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ 
    HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ 
    HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ 
    HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ 
    HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ 
    HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ 
    HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ 
    HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ 
    HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ 
    HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */ 
    HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ 
    HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ 
    HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ 
    HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ 
    II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ 
    II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ 
    II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ 
    II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ 
    II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ 
    II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ 
    II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ 
    II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ 
    II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ 
    II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ 
    II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ 
    II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ 
    II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ 
    II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ 
    II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ 
    II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ 
    state[0] += a; 
    state[1] += b; 
    state[2] += c; 
    state[3] += d; 
    memset ((POINTER)x, 0, sizeof (x)); 
} 

void MD5Init(MD5_CTX *context) 
{ 
    context->count[0] = context->count[1] = 0; 
    context->state[0] = 0x67452301; 
    context->state[1] = 0xefcdab89; 
    context->state[2] = 0x98badcfe; 
    context->state[3] = 0x10325476; 
} 

void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen) 
{ 
    unsigned int i, index, partLen; 

    index = (unsigned int)((context->count[0] >> 3) & 0x3F); 
    if ((context->count[0] += ((UINT4)inputLen << 3))    < ((UINT4)inputLen << 3)) 
        context->count[1]++; 
    context->count[1] += ((UINT4)inputLen >> 29); 
    partLen = 64 - index; 
    if (inputLen >= partLen) 
    { 
        memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen); 
        MD5Transform(context->state, context->buffer); 

        for (i = partLen; i + 63 < inputLen; i += 64)  
            MD5Transform (context->state, &input[i]); 
        index = 0; 
    } 
    else  
    {
        i = 0;  
    }

    memcpy((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i); 
} 

void MD5Final(unsigned char digest[16], MD5_CTX *context) 
{ 
    unsigned char bits[8]; 
    unsigned int index, padLen; 

    Encode (bits, context->count, 8); 
    index = (unsigned int)((context->count[0] >> 3) & 0x3f); 
    padLen = (index < 56) ? (56 - index) : (120 - index); 
    MD5Update (context, PADDING, padLen); 
    MD5Update (context, bits, 8); 
    Encode (digest, context->state, 16); 
    memset ((POINTER)context, 0, sizeof (*context)); 
} 

void MD5Digest(char *pszInput, unsigned long nInputSize, char *pszOutPut) 
{ 
    MD5_CTX context; 
    unsigned int len = strlen (pszInput); 
    MD5Init (&context); 
    MD5Update (&context, (unsigned char *)pszInput, len); 
    MD5Final ((unsigned char *)pszOutPut, &context); 
} 

char* MD5Buffer( const char *pszInput, UINT nInputSize )
{
    char    szDigest[16]; 
    char*   szResult = (char*)malloc(56);
    memset(szResult,0,56);
    MD5_CTX context;  
    MD5Init (&context); 
    MD5Update (&context, (unsigned char *)pszInput, nInputSize); 
    MD5Final ((unsigned char *)szDigest, &context); 
    int i;
    for (i=0;i<16;i++) sprintf (szResult+strlen(szResult),"%02X",(unsigned char)szDigest[i]);
    return szResult;
}
char* testMd5()
{
    char* conc = "StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);";
    char* p = (char*)malloc(2048);
    char* about = NULL;
    int len = 0;
    memset(p,0,2048);
    strcat(p,conc);
    strcat(p,conc);
    strcat(p,conc);
    strcat(p,conc);
    strcat(p,conc);
    strcat(p,conc);
    strcat(p,conc);
    strcat(p,conc);
    len = strlen(p);
    for (int i = 0; i < 100000; i++ )
    {
        if(about)free(about);
        about = MD5Buffer(p,len);
    }
    return about;
}
void main()
{
    int starTicc = GetTickCount();
    fibonacci(45);
    wPrint(L"fibonacci spend: %dms",GetTickCount() - starTicc);
    
    starTicc = GetTickCount();
    free(numberConvert());
    wPrint(L"numberConvert spend: %dms",GetTickCount() - starTicc);
    
    starTicc = GetTickCount();
    free(stringAppend());
    wPrint(L"stringAppend spend: %dms",GetTickCount() - starTicc);
    
    starTicc = GetTickCount();
    free(testMd5());
    wPrint(L"testMd5 spend: %dms",GetTickCount() - starTicc);
}
View Code

这是Snapman页面:

两种代码的设计和实现方法完全一样,其运行结果对比:

C#执行结果:

Snapman执行结果:

结论:

1、函数执行C#要比Snapman慢一些

2、数字转换C#要比Snapman慢一倍多

3、字符串叠加C#使用了最高效的StringBuilder,执行速度和Snapman差不多

4、执行Md5算法,C#就要比Snapman慢了11倍

所以Snapman的脚本运行速度是非常快速的。

Snapman的主页:http://www.snapman.xyz

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:win下轻量级的c语言开发环境配置:vsc + gcc

下一篇:T7314 yyy的巧克力(钟)