← Back to branch summary

~ubuntu-branches/ubuntu/utopic/adios/utopic

« back to all changes in this revision

Viewing changes to src/core/adios_endianness.c

  • Committer: Package Import Robot
  • Author(s): Alastair McKinstry
  • Date: 2013-12-09 15:21:31 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20131209152131-jtd4fpmdv3xnunnm
Tags: 1.5.0-1
* New upstream.
* Standards-Version: 3.9.5
* Include latest config.{sub,guess} 
* New watch file.
* Create libadios-bin for binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/adios_endianness.c
 
1
/* 
 
2
 * ADIOS is freely available under the terms of the BSD license described
 
3
 * in the COPYING file in the top level directory of this source distribution.
 
4
 *
 
5
 * Copyright (c) 2008 - 2009.  UT-BATTELLE, LLC. All rights reserved.
 
6
 */
 
7
 
 
8
#include <stdint.h>
 
9
#include <stdio.h>
 
10
#include "public/adios_types.h"
 
11
#include "core/adios_logger.h"
 
12
 
 
13
void show_bytes(unsigned char * start, int len)
 
14
{
 
15
    int i;
 
16
    for (i = 0; i < len; i ++) {
 
17
        log_info(" %.2x", start[i]);
 
18
    }
 
19
    log_info("\n");
 
20
}
 
21
 
 
22
 
 
23
void swap_16_ptr(void *data) 
 
24
{
 
25
    uint16_t d = *(uint16_t *)data;
 
26
    *(uint16_t *)data = d>>8 | d<<8;
 
27
}
 
28
 
 
29
 
 
30
void swap_32_ptr(void *data)
 
31
{
 
32
    uint32_t d = *(uint32_t *)data;
 
33
    *(uint32_t *)data = ((d&0x000000FF)<<24) 
 
34
                      + ((d&0x0000FF00)<<8)
 
35
                          + ((d&0x00FF0000)>>8)
 
36
                          + ((d&0xFF000000)>>24);
 
37
}
 
38
 
 
39
 
 
40
void swap_64_ptr(void *data)
 
41
{
 
42
    uint64_t d = *(uint64_t *)data;
 
43
    *(uint64_t *)data = ((d&0x00000000000000FF)<<56) 
 
44
                                  + ((d&0x000000000000FF00)<<40)
 
45
                                  + ((d&0x0000000000FF0000)<<24)
 
46
                                  + ((d&0x00000000FF000000)<<8)
 
47
                                  + ((d&0x000000FF00000000LL)>>8)
 
48
                                  + ((d&0x0000FF0000000000LL)>>24)
 
49
                                  + ((d&0x00FF000000000000LL)>>40)
 
50
                                  + ((d&0xFF00000000000000LL)>>56);
 
51
}
 
52
 
 
53
 
 
54
void swap_128_ptr(void *data)
 
55
{
 
56
    uint64_t d = *(uint64_t *)data;
 
57
    *(uint64_t *)data = ((d&0x00000000000000FF)<<56) 
 
58
                                  + ((d&0x000000000000FF00)<<40)
 
59
                                  + ((d&0x0000000000FF0000)<<24)
 
60
                                  + ((d&0x00000000FF000000)<<8)
 
61
                                  + ((d&0x000000FF00000000LL)>>8)
 
62
                                  + ((d&0x0000FF0000000000LL)>>24)
 
63
                                  + ((d&0x00FF000000000000LL)>>40)
 
64
                                  + ((d&0xFF00000000000000LL)>>56);
 
65
    d = *((uint64_t *)data + 1);
 
66
    d = ((d&0x00000000000000FF)<<56) 
 
67
                                  + ((d&0x000000000000FF00)<<40)
 
68
                                  + ((d&0x0000000000FF0000)<<24)
 
69
                                  + ((d&0x00000000FF000000)<<8)
 
70
                                  + ((d&0x000000FF00000000LL)>>8)
 
71
                                  + ((d&0x0000FF0000000000LL)>>24)
 
72
                                  + ((d&0x00FF000000000000LL)>>40)
 
73
                                  + ((d&0xFF00000000000000LL)>>56);
 
74
    *((uint64_t *)data + 1) = *(uint64_t *)data;
 
75
    *(uint64_t *)data = d; 
 
76
}
 
77
 
 
78
 
 
79
void swap_adios_type(void *data, enum ADIOS_DATATYPES type)
 
80
{
 
81
    if(type == adios_string) {
 
82
        return;
 
83
        }
 
84
        else {
 
85
                uint64_t size = adios_get_type_size (type, "");
 
86
 
 
87
                switch (size)
 
88
                {
 
89
                        case 1:
 
90
                                break;
 
91
                        case 2:
 
92
                                swap_16_ptr(data);
 
93
                                break;
 
94
                        case 4:
 
95
                                swap_32_ptr(data);
 
96
                                break;
 
97
                        case 8:
 
98
                                swap_64_ptr(data);
 
99
                                break;
 
100
                        case 16:
 
101
                                swap_128_ptr(data);
 
102
                                break;
 
103
                        case adios_complex:
 
104
                        case adios_double_complex:
 
105
                                // TODO
 
106
                                break;
 
107
                }
 
108
        }
 
109
}
 
110
 
 
111
 
 
112
void swap_adios_type_array(void *data, enum ADIOS_DATATYPES type, uint64_t payload_size)
 
113
{
 
114
    uint64_t size = adios_get_type_size (type, "");
 
115
    uint64_t num_elements = payload_size / size;
 
116
 
 
117
    uint64_t i = 0;
 
118
        for(i = 0; i < num_elements; i ++) {
 
119
        swap_adios_type((char *)data + i*size, type);
 
120
        }    
 
121
}
 
122
 
 
123
void swap_ptr(void * data, int size)
 
124
{
 
125
        switch (size)
 
126
        {
 
127
                case 16:
 
128
                        swap_16_ptr(data);
 
129
                        break;
 
130
                case 32:
 
131
                        swap_32_ptr(data);
 
132
                        break;
 
133
                case 64:
 
134
                        swap_64_ptr(data);
 
135
                        break;
 
136
                case 128:
 
137
                        swap_128_ptr(data);
 
138
                        break;
 
139
        }
 
140
}