static int buffer_to_file(
git_buf *buffer,
const char *path,
mode_t dir_mode,
int file_open_flags,
mode_t file_mode)
{
int fd, error, error_close;
if ((error = git_futils_mkpath2file(path, dir_mode)) < 0)
return error;
if ((fd = p_open(path, file_open_flags, file_mode)) < 0)
return fd;
error = p_write(fd, git_buf_cstr(buffer), git_buf_len(buffer));
error_close = p_close(fd);
if (!error)
error = error_close;
if (!error &&
(file_mode & 0100) != 0 &&
(error = p_chmod(path, file_mode)) < 0)
giterr_set(GITERR_OS, "Failed to set permissions on '%s'", path);
return error;
}
int git_futils_writebuffer(
const git_buf *buf, const char *path, int flags, mode_t mode)
{
int fd, error = 0;
if (flags <= 0)
flags = O_CREAT | O_TRUNC | O_WRONLY;
if (!mode)
mode = GIT_FILEMODE_BLOB;
if ((fd = p_open(path, flags, mode)) < 0) {
giterr_set(GITERR_OS, "Could not open '%s' for writing", path);
return fd;
}
if ((error = p_write(fd, git_buf_cstr(buf), git_buf_len(buf))) < 0) {
giterr_set(GITERR_OS, "Could not write to '%s'", path);
(void)p_close(fd);
return error;
}
if ((error = p_close(fd)) < 0)
giterr_set(GITERR_OS, "Error while closing '%s'", path);
return error;
}
void *print_message_function( void *ptr)
{
char *message;
int i;
//pthread_mutex_lock( &mutex1 ); //for "race condition" no mutex condition
//sleep(1);
message = (char *) ptr;
printf("print_message function \"%s\"\n%lu\n", message, pthread_self());
//p_read("/dev/driver_open0");
p_write("/dev/driver_open0", message);
//sleep(1);
usleep(1);
p_read("/dev/driver_open0");
//pthread_mutex_unlock( &mutex1 ); //for "race condition"
pthread_exit(0);
printf("exit pthread \"%s\"------------\n", message);
}
void cl_git_mkfile(const char *filename, const char *content)
{
int fd;
fd = p_creat(filename, 0666);
cl_assert(fd != 0);
if (content) {
cl_must_pass(p_write(fd, content, strlen(content)));
} else {
cl_must_pass(p_write(fd, filename, strlen(filename)));
cl_must_pass(p_write(fd, "\n", 1));
}
cl_must_pass(p_close(fd));
}
static int repo_write_template(
const char *git_dir, const char *file, mode_t mode, const char *content)
{
git_buf path = GIT_BUF_INIT;
int fd, error = 0;
if (git_buf_joinpath(&path, git_dir, file) < 0)
return -1;
fd = p_open(git_buf_cstr(&path), O_WRONLY | O_CREAT | O_EXCL, mode);
if (fd >= 0) {
error = p_write(fd, content, strlen(content));
p_close(fd);
}
else if (errno != EEXIST)
error = fd;
git_buf_free(&path);
if (error)
giterr_set(GITERR_OS,
"Failed to initialize repository with template '%s'", file);
return error;
}
static void
file_create(const char *filename, const char *content)
{
int fd = p_creat(filename, 0644);
cl_assert(fd >= 0);
cl_must_pass(p_write(fd, content, strlen(content)));
cl_must_pass(p_close(fd));
}
static ssize_t p_write_idxb(struct file* filp, const char* buf, size_t count, loff_t* f_pos)
{
loff_t pos = ((pipes[1].ct)[CONTEXT]).bpos + (*f_pos);
ssize_t ret = p_write(1, filp, buf, count, &pos);
*f_pos = pos - ((pipes[1].ct)[CONTEXT]).bpos;
return ret;
}
void cl_git_write2file(
const char *filename, const char *new_content, int flags, unsigned int mode)
{
int fd = p_open(filename, flags, mode);
cl_assert(fd >= 0);
if (!new_content)
new_content = "\n";
cl_must_pass(p_write(fd, new_content, strlen(new_content)));
cl_must_pass(p_close(fd));
}
static ssize_t p_write_mdab(struct file* filp, const char* buf, size_t count, loff_t* f_pos)
{
#ifdef CONFIG_PROC_PIPE_64_BITS_SUPPORT
if(*f_pos >= pipes[1].mda_size)
#else // CONFIG_PROC_PIPE_64_BITS_SUPPORT
if(*f_pos >= pipes[1].mda->size)
#endif // CONFIG_PROC_PIPE_64_BITS_SUPPORT
return 0;
return p_write(1, filp, buf, count, f_pos);
}
static int lock_file(git_filebuf *file, int flags)
{
if (git_path_exists(file->path_lock) == true) {
if (flags & GIT_FILEBUF_FORCE)
p_unlink(file->path_lock);
else {
giterr_clear(); /* actual OS error code just confuses */
giterr_set(GITERR_OS,
"Failed to lock file '%s' for writing", file->path_lock);
return -1;
}
}
/* create path to the file buffer is required */
if (flags & GIT_FILEBUF_FORCE) {
/* XXX: Should dirmode here be configurable? Or is 0777 always fine? */
file->fd = git_futils_creat_locked_withpath(file->path_lock, 0777, GIT_LOCK_FILE_MODE);
} else {
file->fd = git_futils_creat_locked(file->path_lock, GIT_LOCK_FILE_MODE);
}
if (file->fd < 0)
return -1;
file->fd_is_open = true;
if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) {
git_file source;
char buffer[2048];
ssize_t read_bytes;
source = p_open(file->path_original, O_RDONLY);
if (source < 0) {
giterr_set(GITERR_OS,
"Failed to open file '%s' for reading",
file->path_original);
return -1;
}
while ((read_bytes = p_read(source, buffer, sizeof(buffer))) > 0) {
p_write(file->fd, buffer, read_bytes);
if (file->digest)
git_hash_update(file->digest, buffer, read_bytes);
}
p_close(source);
if (read_bytes < 0) {
giterr_set(GITERR_OS, "Failed to read file '%s'", file->path_original);
return -1;
}
}
return 0;
}
/* Send an array to the serail port , maybe should be moved to serail.c */
int sendString(int fd, int length, uint8* dat)
{
int res=0;
res = p_write(fd, dat, length);
if( res <= 0 ) {
puts("ERROR");
return -1;
}
}
static void write_object_files(object_data *d)
{
int fd;
if (p_mkdir(d->dir, GIT_OBJECT_DIR_MODE) < 0)
cl_assert(errno == EEXIST);
cl_assert((fd = p_creat(d->file, S_IREAD | S_IWRITE)) >= 0);
cl_must_pass(p_write(fd, d->bytes, d->blen));
p_close(fd);
}
void cl_git_write2file(
const char *path, const char *content, size_t content_len,
int flags, unsigned int mode)
{
int fd;
cl_assert(path && content);
cl_assert((fd = p_open(path, flags, mode)) >= 0);
if (!content_len)
content_len = strlen(content);
cl_must_pass(p_write(fd, content, content_len));
cl_must_pass(p_close(fd));
}
static int write_normal(git_filebuf *file, void *source, size_t len)
{
if (len > 0) {
if (p_write(file->fd, (void *)source, len) < 0) {
file->last_error = BUFERR_WRITE;
return -1;
}
if (file->digest)
git_hash_update(file->digest, source, len);
}
return 0;
}
static int file_create(const char *filename, const char *content)
{
int fd;
fd = p_creat(filename, 0666);
if (fd == 0)
return GIT_ERROR;
if (p_write(fd, content, strlen(content)) != 0)
return GIT_ERROR;
if (p_close(fd) != 0)
return GIT_ERROR;
return GIT_SUCCESS;
}
static void write_file(const char *path, const char *content)
{
git_file file;
int error;
if (git_path_exists(path)) {
cl_git_pass(p_unlink(path));
}
file = git_futils_creat_withpath(path, 0777, 0666);
cl_assert(file >= 0);
error = p_write(file, content, strlen(content) * sizeof(char));
p_close(file);
cl_git_pass(error);
}
// Helpers
static void copy_file(const char *src, const char *dst)
{
git_buf source_buf = GIT_BUF_INIT;
git_file dst_fd;
cl_git_pass(git_futils_readbuffer(&source_buf, src));
dst_fd = git_futils_creat_withpath(dst, 0777, 0666);
if (dst_fd < 0)
goto cleanup;
cl_git_pass(p_write(dst_fd, source_buf.ptr, source_buf.size));
cleanup:
git_buf_free(&source_buf);
p_close(dst_fd);
}
/* make sure GIT_FILEBUF_APPEND works as expected */
void test_core_filebuf__1(void)
{
git_filebuf file;
int fd;
char test[] = "test";
fd = p_creat(test, 0644);
cl_must_pass(fd);
cl_must_pass(p_write(fd, "libgit2 rocks\n", 14));
cl_must_pass(p_close(fd));
cl_git_pass(git_filebuf_open(&file, test, GIT_FILEBUF_APPEND));
cl_git_pass(git_filebuf_printf(&file, "%s\n", "libgit2 rocks"));
cl_git_pass(git_filebuf_commit(&file));
cl_must_pass(p_unlink(test));
}
int git_futils_writebuffer(
const git_buf *buf, const char *path, int flags, mode_t mode)
{
int fd, do_fsync = 0, error = 0;
if (!flags)
flags = O_CREAT | O_TRUNC | O_WRONLY;
if ((flags & O_FSYNC) != 0)
do_fsync = 1;
flags &= ~O_FSYNC;
if (!mode)
mode = GIT_FILEMODE_BLOB;
if ((fd = p_open(path, flags, mode)) < 0) {
giterr_set(GITERR_OS, "could not open '%s' for writing", path);
return fd;
}
if ((error = p_write(fd, git_buf_cstr(buf), git_buf_len(buf))) < 0) {
giterr_set(GITERR_OS, "could not write to '%s'", path);
(void)p_close(fd);
return error;
}
if (do_fsync && (error = p_fsync(fd)) < 0) {
giterr_set(GITERR_OS, "could not fsync '%s'", path);
p_close(fd);
return error;
}
if ((error = p_close(fd)) < 0) {
giterr_set(GITERR_OS, "error while closing '%s'", path);
return error;
}
if (do_fsync && (flags & O_CREAT))
error = git_futils_fsync_parent(path);
return error;
}
static int write_deflate(git_filebuf *file, void *source, size_t len)
{
z_stream *zs = &file->zs;
if (len > 0 || file->flush_mode == Z_FINISH) {
zs->next_in = source;
zs->avail_in = (uInt)len;
do {
size_t have;
zs->next_out = file->z_buf;
zs->avail_out = (uInt)file->buf_size;
if (deflate(zs, file->flush_mode) == Z_STREAM_ERROR) {
file->last_error = BUFERR_ZLIB;
return -1;
}
have = file->buf_size - (size_t)zs->avail_out;
if (p_write(file->fd, file->z_buf, have) < 0) {
file->last_error = BUFERR_WRITE;
return -1;
}
} while (zs->avail_out == 0);
assert(zs->avail_in == 0);
if (file->digest)
git_hash_update(file->digest, source, len);
}
return 0;
}
#include "fileops.h"
#include "git2/status.h"
static const char *test_blob_oid = "d4fa8600b4f37d7516bef4816ae2c64dbf029e3a";
#define STATUS_WORKDIR_FOLDER TEST_RESOURCES "/status/"
#define STATUS_REPOSITORY_TEMP_FOLDER TEMP_REPO_FOLDER ".gitted/"
BEGIN_TEST(file0, "test retrieving OID from a file apart from the ODB")
git_oid expected_id, actual_id;
char filename[] = "new_file";
int fd;
fd = p_creat(filename, 0644);
must_pass(fd);
must_pass(p_write(fd, "new_file\n", 9));
must_pass(p_close(fd));
must_pass(git_odb_hashfile(&actual_id, filename, GIT_OBJ_BLOB));
must_pass(git_oid_fromstr(&expected_id, test_blob_oid));
must_be_true(git_oid_cmp(&expected_id, &actual_id) == 0);
must_pass(p_unlink(filename));
END_TEST
static const char *entry_paths[] = {
"current_file",
"file_deleted",
"modified_file",
"new_file",
void test_repo_open__from_git_new_workdir(void)
{
/* The git-new-workdir script that ships with git sets up a bunch of
* symlinks to create a second workdir that shares the object db with
* another checkout. Libgit2 can open a repo that has been configured
* this way.
*/
cl_git_sandbox_init("empty_standard_repo");
#ifndef GIT_WIN32
git_repository *repo2;
git_buf link_tgt = GIT_BUF_INIT, link = GIT_BUF_INIT, body = GIT_BUF_INIT;
const char **scan;
int link_fd;
static const char *links[] = {
"config", "refs", "logs/refs", "objects", "info", "hooks",
"packed-refs", "remotes", "rr-cache", "svn", NULL
};
static const char *copies[] = {
"HEAD", NULL
};
cl_git_pass(p_mkdir("alternate", 0777));
cl_git_pass(p_mkdir("alternate/.git", 0777));
for (scan = links; *scan != NULL; scan++) {
git_buf_joinpath(&link_tgt, "empty_standard_repo/.git", *scan);
if (git_path_exists(link_tgt.ptr)) {
git_buf_joinpath(&link_tgt, "../../empty_standard_repo/.git", *scan);
git_buf_joinpath(&link, "alternate/.git", *scan);
if (strchr(*scan, '/'))
git_futils_mkpath2file(link.ptr, 0777);
cl_assert_(symlink(link_tgt.ptr, link.ptr) == 0, strerror(errno));
}
}
for (scan = copies; *scan != NULL; scan++) {
git_buf_joinpath(&link_tgt, "empty_standard_repo/.git", *scan);
if (git_path_exists(link_tgt.ptr)) {
git_buf_joinpath(&link, "alternate/.git", *scan);
cl_git_pass(git_futils_readbuffer(&body, link_tgt.ptr));
cl_assert((link_fd = git_futils_creat_withpath(link.ptr, 0777, 0666)) >= 0);
cl_must_pass(p_write(link_fd, body.ptr, body.size));
p_close(link_fd);
}
}
git_buf_free(&link_tgt);
git_buf_free(&link);
git_buf_free(&body);
cl_git_pass(git_repository_open(&repo2, "alternate"));
cl_assert(git_repository_path(repo2) != NULL);
cl_assert_(git__suffixcmp(git_repository_path(repo2), "alternate/.git/") == 0, git_repository_path(repo2));
cl_assert(git_repository_workdir(repo2) != NULL);
cl_assert_(git__suffixcmp(git_repository_workdir(repo2), "alternate/") == 0, git_repository_workdir(repo2));
git_repository_free(repo2);
#endif
}
int main(int argc, char *argv[])
{
p_mem_t shared_mem, results_mem;
uint32_t eram_base;
char results[1024] = { '\0' };
int device_cols, device_rows, nside;
p_dev_t dev;
p_prog_t prog;
p_team_t team;
p_coords_t size;
p_coords_t start = { .row = 0, .col = 0 };
unsigned int msize;
float seed;
unsigned int addr; //, clocks;
size_t sz;
int verbose=0;
double tdiff[3];
int result, retval = 0;
msize = 0x00400000;
get_args(argc, argv);
fo = stderr;
fi = stdin;
printf( "------------------------------------------------------------\n");
printf( "Calculating: C[%d][%d] = A[%d][%d] * B[%d][%d]\n", _Smtx, _Smtx, _Smtx, _Smtx, _Smtx, _Smtx);
seed = 0.0;
if(verbose){
printf( "Seed = %f\n", seed);
}
dev = p_init(P_DEV_EPIPHANY, 0);
if (p_error(dev)) {
fprintf(stderr, "Error initializing PAL\n");
return p_error(dev);
}
device_cols = p_query(dev, P_PROP_COLS);
device_rows = p_query(dev, P_PROP_ROWS);
// Use min size
nside = device_cols > device_rows ? device_cols : device_rows;
if (nside < 4) {
fprintf(stderr, "Error: Too small device, need at least 4x4\n");
return 1;
}
// Either 1024, 256, 64, or 16 cores (side must be power of two),
nside = nside >= 32 ? 32 : nside >= 16 ? 16 : nside >= 8 ? 8 : 4;
size.row = nside;
size.col = nside;
team = p_open4(dev, P_TOPOLOGY_2D, &start, &size);
printf("Using team of size %d\n", p_team_size(team));
if (p_error(team)) {
fprintf(stderr, "Error opening team\n");
return p_error(team);
}
prog = p_load(dev, ar.elfFile, 0);
eram_base = (unsigned) p_query(dev, P_PROP_MEMBASE);
shared_mem = p_map(dev, eram_base, msize);
// Clear mailbox contents
memset(&Mailbox, 0, sizeof(Mailbox));
p_write(&shared_mem, &Mailbox, 0, sizeof(Mailbox), 0);
// Generate operand matrices based on a provided seed
matrix_init((int)seed);
#ifdef __WIPE_OUT_RESULT_MATRIX__
// Wipe-out any previous remains in result matrix (for verification)
addr = offsetof(shared_buf_t, C[0]);
sz = sizeof(Mailbox.C);
if(verbose){
printf( "Writing C[%uB] to address %08x...\n", (unsigned) sz, addr);
}
p_write(&shared_mem, (void *) Mailbox.C, addr, sz, 0);
#endif
/* Wallclock time */
clock_gettime(CLOCK_MONOTONIC, &timer[0]);
/* Clock CPUTIME too. We don't want to indicate failure just
* because the system was under high load. */
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[4]);
// Copy operand matrices to Epiphany system
addr = offsetof(shared_buf_t, A[0]);
sz = sizeof(Mailbox.A);
if(verbose){
printf( "Writing A[%uB] to address %08x...\n", (unsigned) sz, addr);
}
p_write(&shared_mem, (void *) Mailbox.A, addr, sz, 0);
addr = offsetof(shared_buf_t, B[0]);
sz = sizeof(Mailbox.B);
if(verbose){
printf( "Writing B[%uB] to address %08x...\n", (unsigned) sz, addr);
}
p_write(&shared_mem, (void *) Mailbox.B, addr, sz, 0);
// Call the Epiphany matmul() function
if(verbose){
printf( "GO Epiphany! ... ");
}
if(verbose){
printf("Loading program on Epiphany chip...\n");
}
p_arg_t args[] = { &nside, sizeof(nside), true };
if (p_run(prog, "matmul", team, 0, p_team_size(team), 1, args, 0)) {
fprintf(stderr, "Error loading Epiphany program.\n");
exit(1);
}
// Read result matrix and timing
addr = offsetof(shared_buf_t, C[0]);
sz = sizeof(Mailbox.C);
if(verbose){
printf( "Reading result from address %08x...\n", addr);
}
p_read(&shared_mem, (void *) Mailbox.C, addr, sz, 0);
clock_gettime(CLOCK_MONOTONIC, &timer[1]);
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[5]);
// Calculate a reference result
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[2]);
#ifndef __DO_STRASSEN__
matmul(Mailbox.A, Mailbox.B, Cref, _Smtx);
#else
matmul_strassen(Mailbox.A, Mailbox.B, Cref, _Smtx);
#endif
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &timer[3]);
addr = offsetof(shared_buf_t, core.clocks);
sz = sizeof(Mailbox.core.clocks);
if(verbose){
printf( "Reading time from address %08x...\n", addr);
}
p_read(&shared_mem, &Mailbox.core.clocks, addr, sizeof(Mailbox.core.clocks), 0);
// clocks = Mailbox.core.clocks;
// Calculate the difference between the Epiphany result and the reference result
matsub(Mailbox.C, Cref, Cdiff, _Smtx);
tdiff[0] = (timer[1].tv_sec - timer[0].tv_sec) * 1000 + ((double) (timer[1].tv_nsec - timer[0].tv_nsec) / 1000000.0);
// tdiff[0] = ((double) clocks) / eMHz * 1000;
tdiff[1] = (timer[3].tv_sec - timer[2].tv_sec) * 1000 + ((double) (timer[3].tv_nsec - timer[2].tv_nsec) / 1000000.0);
tdiff[2] = (timer[5].tv_sec - timer[4].tv_sec) * 1000 + ((double) (timer[5].tv_nsec - timer[4].tv_nsec) / 1000000.0);
// If the difference is 0, then the matrices are identical and the
// calculation was correct
if (iszero(Cdiff, _Smtx))
{
printf( "Epiphany(time) %9.1f msec (@ %03d MHz)\n", tdiff[0], eMHz);
printf( "Host(time) %9.1f msec (@ %03d MHz)\n", tdiff[1], aMHz);
printf( "------------------------------------------------------------\n");
printf( "TEST \"matmul-16\" PASSED\n");
retval = 0;
} else {
printf( "\n\nERROR: C_epiphany is different from C_host !!!\n");
printf( "TEST \"matmul-16\" FAILED\n");
retval = 1;
}
#if 0
#ifdef __DUMP_MATRICES__
printf( "\n\n\n");
printf( "A[][] = \n");
matprt(Mailbox.A, _Smtx);
printf( "B[][] = \n");
matprt(Mailbox.B, _Smtx);
printf( "C[][] = \n");
matprt(Mailbox.C, _Smtx);
printf( "Cref[][] = \n");
matprt(Cref, _Smtx);
int i, j;
for (i=0; i<_Nside; i++)
for (j=0; j<_Nside; j++)
{
e_read(pEpiphany, i, j, 0x2000+0*sizeof(float), &Aepi[(i*_Score+0)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x2000+2*sizeof(float), &Aepi[(i*_Score+1)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x4000+0*sizeof(float), &Bepi[(i*_Score+0)*_Smtx + j*_Score], 2*sizeof(float));
e_read(pEpiphany, i, j, 0x4000+2*sizeof(float), &Bepi[(i*_Score+1)*_Smtx + j*_Score], 2*sizeof(float));
}
printf( "Aepi[][] = \n");
matprt(Aepi, _Smtx);
printf( "Bepi[][] = \n");
matprt(Bepi, _Smtx);
#endif
#endif
// p_unmap ...
p_close(team);
p_finalize(dev);
return retval;
}
// Initialize operand matrices
void matrix_init(int seed)
{
int i, j, p;
p = 0;
for (i=0; i<_Smtx; i++)
for (j=0; j<_Smtx; j++)
Mailbox.A[p++] = (i + j + seed) % _MAX_MEMBER_;
p = 0;
for (i=0; i<_Smtx; i++)
for (j=0; j<_Smtx; j++)
Mailbox.B[p++] = ((i + j) * 2 + seed) % _MAX_MEMBER_;
p = 0;
for (i=0; i<_Smtx; i++)
for (j=0; j<_Smtx; j++)
Mailbox.C[p++] = 0x8dead;
return;
}
