make
mkdir -p build
/usr/local/cuda/bin/nvcc -c -I/usr/local/cuda/include *.cu
nvcc warning : The 'compute_10' and 'sm_10' architectures are deprecated, and may be removed in a future release.
ptxas /var/folders/8v/1gw9hxtx40qdp2slztw3whq80000gn/T//tmpxft_00012625_00000000-5_CUDA_ConvNN.ptx, line 745; warning : Double is not supported. Demoting to float
clang++ -std=c++11 -c -m32 -I/usr/local/cuda/include *.cpp
/usr/local/cuda/bin/nvcc -m32 -L/usr/local/cuda/lib -lcuda -lcudart -lm -o build/main *.o
nvcc warning : The 'compute_10' and 'sm_10' architectures are deprecated, and may be removed in a future release.
clang: error: unknown argument: '-malign-double' [-Wunused-command-line-argument-hard-error-in-future]
clang: note: this will be a hard error (cannot be downgraded to a warning) in the future
make: *** [build] Error 1

here the makefile:
------------------
------------------
PROJECT_NAME = main

# NVCC is path to nvcc. Here it is assumed /usr/local/cuda is on one's PATH.
# CC is the compiler for C++ host code.

NVCC = /usr/local/cuda/bin/nvcc
CC = clang++ -std=c++11

CUDAPATH = /usr/local/cuda
#  Directories to search for
#CUDA_ROOT = /usr/local/cuda
#SDK_HOME = /Developer/NVIDIA/CUDA-6.0/C

BUILD_DIR = build
# note that nvcc defaults to 32-bit architecture. thus, force C/LFLAGS to comply.
# you could also force nvcc to compile 64-bit with -m64 flag. (and remove -m32 instances)

CFLAGS = -c -m32 -I$(CUDAPATH)/include
NVCCFLAGS = -c -I$(CUDAPATH)/include
LFLAGS = -m32 -L$(CUDAPATH)/lib -lcuda -lcudart -lm

all: build clean

build: build_dir gpu cpu
	$(NVCC) $(LFLAGS) -o $(BUILD_DIR)/$(PROJECT_NAME) *.o

build_dir:
	mkdir -p $(BUILD_DIR)

gpu:
	$(NVCC) $(NVCCFLAGS) *.cu

cpu:			
	$(CC) $(CFLAGS) *.cpp

clean:
	rm *.o

run:
	./$(BUILD_DIR)/$(PROJECT_NAME)

bWFrZQpta2RpciAtcCBidWlsZAovdXNyL2xvY2FsL2N1ZGEvYmluL252Y2MgLWMgLUkvdXNyL2xvY2FsL2N1ZGEvaW5jbHVkZSAqLmN1Cm52Y2Mgd2FybmluZyA6IFRoZSAnY29tcHV0ZV8xMCcgYW5kICdzbV8xMCcgYXJjaGl0ZWN0dXJlcyBhcmUgZGVwcmVjYXRlZCwgYW5kIG1heSBiZSByZW1vdmVkIGluIGEgZnV0dXJlIHJlbGVhc2UuCnB0eGFzIC92YXIvZm9sZGVycy84di8xZ3c5aHh0eDQwcWRwMnNsenR3M3docTgwMDAwZ24vVC8vdG1weGZ0XzAwMDEyNjI1XzAwMDAwMDAwLTVfQ1VEQV9Db252Tk4ucHR4LCBsaW5lIDc0NTsgd2FybmluZyA6IERvdWJsZSBpcyBub3Qgc3VwcG9ydGVkLiBEZW1vdGluZyB0byBmbG9hdApjbGFuZysrIC1zdGQ9YysrMTEgLWMgLW0zMiAtSS91c3IvbG9jYWwvY3VkYS9pbmNsdWRlICouY3BwCi91c3IvbG9jYWwvY3VkYS9iaW4vbnZjYyAtbTMyIC1ML3Vzci9sb2NhbC9jdWRhL2xpYiAtbGN1ZGEgLWxjdWRhcnQgLWxtIC1vIGJ1aWxkL21haW4gKi5vCm52Y2Mgd2FybmluZyA6IFRoZSAnY29tcHV0ZV8xMCcgYW5kICdzbV8xMCcgYXJjaGl0ZWN0dXJlcyBhcmUgZGVwcmVjYXRlZCwgYW5kIG1heSBiZSByZW1vdmVkIGluIGEgZnV0dXJlIHJlbGVhc2UuCmNsYW5nOiBlcnJvcjogdW5rbm93biBhcmd1bWVudDogJy1tYWxpZ24tZG91YmxlJyBbLVd1bnVzZWQtY29tbWFuZC1saW5lLWFyZ3VtZW50LWhhcmQtZXJyb3ItaW4tZnV0dXJlXQpjbGFuZzogbm90ZTogdGhpcyB3aWxsIGJlIGEgaGFyZCBlcnJvciAoY2Fubm90IGJlIGRvd25ncmFkZWQgdG8gYSB3YXJuaW5nKSBpbiB0aGUgZnV0dXJlCm1ha2U6ICoqKiBbYnVpbGRdIEVycm9yIDEKCmhlcmUgdGhlIG1ha2VmaWxlOgotLS0tLS0tLS0tLS0tLS0tLS0KLS0tLS0tLS0tLS0tLS0tLS0tClBST0pFQ1RfTkFNRSA9IG1haW4KCiMgTlZDQyBpcyBwYXRoIHRvIG52Y2MuIEhlcmUgaXQgaXMgYXNzdW1lZCAvdXNyL2xvY2FsL2N1ZGEgaXMgb24gb25lJ3MgUEFUSC4KIyBDQyBpcyB0aGUgY29tcGlsZXIgZm9yIEMrKyBob3N0IGNvZGUuCgpOVkNDID0gL3Vzci9sb2NhbC9jdWRhL2Jpbi9udmNjCkNDID0gY2xhbmcrKyAtc3RkPWMrKzExCgpDVURBUEFUSCA9IC91c3IvbG9jYWwvY3VkYQojICBEaXJlY3RvcmllcyB0byBzZWFyY2ggZm9yCiNDVURBX1JPT1QgPSAvdXNyL2xvY2FsL2N1ZGEKI1NES19IT01FID0gL0RldmVsb3Blci9OVklESUEvQ1VEQS02LjAvQwoKQlVJTERfRElSID0gYnVpbGQKIyBub3RlIHRoYXQgbnZjYyBkZWZhdWx0cyB0byAzMi1iaXQgYXJjaGl0ZWN0dXJlLiB0aHVzLCBmb3JjZSBDL0xGTEFHUyB0byBjb21wbHkuCiMgeW91IGNvdWxkIGFsc28gZm9yY2UgbnZjYyB0byBjb21waWxlIDY0LWJpdCB3aXRoIC1tNjQgZmxhZy4gKGFuZCByZW1vdmUgLW0zMiBpbnN0YW5jZXMpCgpDRkxBR1MgPSAtYyAtbTMyIC1JJChDVURBUEFUSCkvaW5jbHVkZQpOVkNDRkxBR1MgPSAtYyAtSSQoQ1VEQVBBVEgpL2luY2x1ZGUKTEZMQUdTID0gLW0zMiAtTCQoQ1VEQVBBVEgpL2xpYiAtbGN1ZGEgLWxjdWRhcnQgLWxtCgphbGw6IGJ1aWxkIGNsZWFuCgpidWlsZDogYnVpbGRfZGlyIGdwdSBjcHUKCSQoTlZDQykgJChMRkxBR1MpIC1vICQoQlVJTERfRElSKS8kKFBST0pFQ1RfTkFNRSkgKi5vCgpidWlsZF9kaXI6Cglta2RpciAtcCAkKEJVSUxEX0RJUikKCmdwdToKCSQoTlZDQykgJChOVkNDRkxBR1MpICouY3UKCmNwdToJCQkKCSQoQ0MpICQoQ0ZMQUdTKSAqLmNwcAoKY2xlYW46CglybSAqLm8KCnJ1bjoKCS4vJChCVUlMRF9ESVIpLyQoUFJPSkVDVF9OQU1FKQ==

I2luY2x1ZGUgJmx0O3N0ZGlvLmgmZ3Q7CiNkZWZpbmUgU0laRQkxMDI0CgpfX2dsb2JhbF9fIHZvaWQgVmVjdG9yQWRkKGludCAqYSwgaW50ICpiLCBpbnQgKmMsIGludCBuKQp7CglpbnQgaT10aHJlYWRJZHgueDsKCglpZiAoaSAmbHQ7IG4pCgkJY1tpXSA9IGFbaV0gKyBiW2ldOwp9CgppbnQgbWFpbigpCnsKCWludCAqYSwgKmIsICpjOwoKCWN1ZGFNYWxsb2NNYW5hZ2VkKCZhbXA7YSwgU0laRSAqIHNpemVvZihpbnQpKTsKCWN1ZGFNYWxsb2NNYW5hZ2VkKCZhbXA7YiwgU0laRSAqIHNpemVvZihpbnQpKTsKCWN1ZGFNYWxsb2NNYW5hZ2VkKCZhbXA7YywgU0laRSAqIHNpemVvZihpbnQpKTsKCglmb3IgKGludCBpID0gMDsgaSAmbHQ7IFNJWkU7ICsraSkKCXsKCQlhW2ldID0gaTsKCQliW2ldID0gaTsKCQljW2ldID0gMDsKCX0KCglWZWN0b3JBZGQgJmx0OyZsdDsmbHQ7MSwgU0laRSZndDsmZ3Q7Jmd0OyAoYSwgYiwgYywgU0laRSk7CgoJY3VkYURldmljZVN5bmNocm9uaXplKCk7CgoJZm9yIChpbnQgaSA9IDA7IGkgJmx0OyAxMDsgKytpKQoJCXByaW50ZigmcXVvdDtjWyVkXSA9ICVkXG4mcXVvdDssIGksIGNbaV0pOwoKCWN1ZGFGcmVlKGEpOwoJY3VkYUZyZWUoYik7CgljdWRhRnJlZShjKTsKCglyZXR1cm4gMDsKfQ==

#include <stdio.h>
#define SIZE	1024

__global__ void VectorAdd(int *a, int *b, int *c, int n)
{
	int i=threadIdx.x;

	if (i < n)
		c[i] = a[i] + b[i];
}

int main()
{
	int *a, *b, *c;

	cudaMallocManaged(&a, SIZE * sizeof(int));
	cudaMallocManaged(&b, SIZE * sizeof(int));
	cudaMallocManaged(&c, SIZE * sizeof(int));

	for (int i = 0; i < SIZE; ++i)
	{
		a[i] = i;
		b[i] = i;
		c[i] = 0;
	}

	VectorAdd <<<1, SIZE>>> (a, b, c, SIZE);

	cudaDeviceSynchronize();

	for (int i = 0; i < 10; ++i)
		printf("c[%d] = %d\n", i, c[i]);

	cudaFree(a);
	cudaFree(b);
	cudaFree(c);

	return 0;
}