Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib

    r3ce0d440 re9a7e90b  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 08:46:35 2018
    13 // Update Count     : 306
     12// Last Modified On : Wed May 16 07:53:10 2018
     13// Update Count     : 300
    1414//
    1515
    1616#pragma once
    1717
    18 #include <stdlib.h>                                                                             // allocation, strto*, *abs
    19 extern "C" {
    20         void * memalign( size_t align, size_t size );
    21         void * aligned_alloc( size_t align, size_t size );
    22         void * memset( void * dest, int c, size_t size );
    23 } // extern "C"
     18#include <stdlib.h>                                                                             // strto*, *abs
    2419
    2520//---------------------------------------
    … …  
    3227//---------------------------------------
    3328
     29// C dynamic allocation
    3430static inline forall( dtype T | sized(T) ) {
    35         // C dynamic allocation
    36 
    3731        T * malloc( void ) {
    3832                // printf( "* malloc\n" );
    … …  
    5751        } // realloc
    5852
     53        extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
    5954        T * memalign( size_t align ) {
    6055                //printf( "X4\n" );
    … …  
    6257        } // memalign
    6358
     59        extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void *
    6460        T * aligned_alloc( size_t align ) {
    6561                //printf( "X5\n" );
    … …  
    7470
    7571        // Cforall dynamic allocation
     72        extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
    7673
    7774        T * alloc( void ) {
    … …  
    106103forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
    107104
    108 
    109 static inline forall( dtype T | sized(T) ) {
    110         T * align_alloc( size_t align ) {
    111                 //printf( "X13\n" );
    112                 return (T *)memalign( align, sizeof(T) );
    113         } // align_alloc
    114 
    115         T * align_alloc( size_t align, char fill ) {
    116                 //printf( "X14\n" );
    117                 T * ptr = (T *)memalign( align, sizeof(T) );
    118                 return (T *)memset( ptr, (int)fill, sizeof(T) );
    119         } // align_alloc
    120 
    121         T * align_alloc( size_t align, size_t dim ) {
    122                 //printf( "X15\n" );
    123                 return (T *)memalign( align, dim * sizeof(T) );
    124         } // align_alloc
    125 
    126         T * align_alloc( size_t align, size_t dim, char fill ) {
    127                 //printf( "X16\n" );
    128                 T * ptr = (T *)memalign( align, dim * sizeof(T) );
    129                 return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
    130         } // align_alloc
    131 } // distribution
    132 
    133 
    134 static inline forall( dtype T | sized(T) ) {
    135         // data, non-array types
    136 
    137         T * memset( T * dest, char c ) {
    138                 //printf( "X17\n" );
    139                 return (T *)memset( dest, c, sizeof(T) );
    140         } // memset
    141 
    142         extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    143 
    144         T * memcpy( T * dest, const T * src ) {
    145                 //printf( "X18\n" );
    146                 return (T *)memcpy( dest, src, sizeof(T) );
    147         } // memcpy
    148 } // distribution
    149 
    150 static inline forall( dtype T | sized(T) ) {
    151         // data, array types
    152 
    153         T * memset( T dest[], size_t dim, char c ) {
    154                 //printf( "X19\n" );
    155                 return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
    156         } // memset
    157 
    158         T * memcpy( T dest[], const T src[], size_t dim ) {
    159                 //printf( "X20\n" );
    160                 return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
    161         } // memcpy
    162 } // distribution
     105static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
     106        //printf( "X13\n" );
     107        return (T *)memalign( align, sizeof(T) );
     108} // align_alloc
     109static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
     110        //printf( "X14\n" );
     111    T * ptr = (T *)memalign( align, sizeof(T) );
     112    return (T *)memset( ptr, (int)fill, sizeof(T) );
     113} // align_alloc
     114
     115static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
     116        //printf( "X15\n" );
     117        return (T *)memalign( align, dim * sizeof(T) );
     118} // align_alloc
     119static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
     120        //printf( "X16\n" );
     121    T * ptr = (T *)memalign( align, dim * sizeof(T) );
     122    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
     123} // align_alloc
     124
     125
     126// data, non-array types
     127static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
     128        //printf( "X17\n" );
     129        return (T *)memset( dest, c, sizeof(T) );
     130} // memset
     131extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
     132static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
     133        //printf( "X18\n" );
     134        return (T *)memcpy( dest, src, sizeof(T) );
     135} // memcpy
     136
     137// data, array types
     138static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
     139        //printf( "X19\n" );
     140        return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
     141} // memset
     142static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
     143        //printf( "X20\n" );
     144        return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
     145} // memcpy
    163146
    164147// allocation/deallocation and constructor/destructor, non-array types
    … …  
    206189//---------------------------------------
    207190
    208 forall( otype E | { int ?<?( E, E ); } ) {
    209         E * bsearch( E key, const E * vals, size_t dim );
    210         size_t bsearch( E key, const E * vals, size_t dim );
    211         E * bsearchl( E key, const E * vals, size_t dim );
    212         size_t bsearchl( E key, const E * vals, size_t dim );
    213         E * bsearchu( E key, const E * vals, size_t dim );
    214         size_t bsearchu( E key, const E * vals, size_t dim );
    215 
    216         void qsort( E * vals, size_t dim );
    217 } // distribution
    218 
    219 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
    220         E * bsearch( K key, const E * vals, size_t dim );
    221         size_t bsearch( K key, const E * vals, size_t dim );
    222         E * bsearchl( K key, const E * vals, size_t dim );
    223         size_t bsearchl( K key, const E * vals, size_t dim );
    224         E * bsearchu( K key, const E * vals, size_t dim );
    225         size_t bsearchu( K key, const E * vals, size_t dim );
    226 } // distribution
     191forall( otype E | { int ?<?( E, E ); } )
     192E * bsearch( E key, const E * vals, size_t dim );
     193
     194forall( otype E | { int ?<?( E, E ); } )
     195size_t bsearch( E key, const E * vals, size_t dim );
     196
     197forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     198E * bsearch( K key, const E * vals, size_t dim );
     199
     200forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     201size_t bsearch( K key, const E * vals, size_t dim );
     202
     203
     204forall( otype E | { int ?<?( E, E ); } )
     205E * bsearchl( E key, const E * vals, size_t dim );
     206
     207forall( otype E | { int ?<?( E, E ); } )
     208size_t bsearchl( E key, const E * vals, size_t dim );
     209
     210forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     211E * bsearchl( K key, const E * vals, size_t dim );
     212
     213forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     214size_t bsearchl( K key, const E * vals, size_t dim );
     215
     216
     217forall( otype E | { int ?<?( E, E ); } )
     218E * bsearchu( E key, const E * vals, size_t dim );
     219
     220forall( otype E | { int ?<?( E, E ); } )
     221size_t bsearchu( E key, const E * vals, size_t dim );
     222
     223forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     224E * bsearchu( K key, const E * vals, size_t dim );
     225
     226forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     227size_t bsearchu( K key, const E * vals, size_t dim );
     228
     229
     230forall( otype E | { int ?<?( E, E ); } )
     231void qsort( E * vals, size_t dim );
    227232
    228233//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.